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


#define SWIG_VERSION 0x040400
#define SWIGPYTHON
#define SWIG_DIRECTORS
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE

#define SWIG_name    "_pyagrum"
/* -----------------------------------------------------------------------------
 *  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(__cplusplus) && __cplusplus >=201103L
# define SWIG_NULLPTR nullptr
#else
# define SWIG_NULLPTR NULL
#endif 

/* -----------------------------------------------------------------------------
 * swigcompat.swg
 *
 * Macros to provide support compatibility with older C and C++ standards.
 *
 * Note that SWIG expects __cplusplus to be defined to the appropriate C++ standard.
 * MSVC users are urged to check and examine the /Zc:__cplusplus compiler option.
 * See https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus.
 * ----------------------------------------------------------------------------- */

/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
 * if you're missing it.
 */
#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
     (defined __cplusplus && __cplusplus >= 201103L) || \
     defined SWIG_HAVE_SNPRINTF) && \
    !defined SWIG_NO_SNPRINTF
# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
#else
/* Fallback versions ignore the buffer size, but most of our uses either have a
 * fixed maximum possible size or dynamically allocate a buffer that's large
 * enough.
 */
# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
#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(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif

#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif

#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */

#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
 * See https://github.com/swig/swig/issues/2090 */
# include <corecrt.h>
#endif

# undef _DEBUG
# include <Python.h>
# define _DEBUG 1
#else
# include <Python.h>
#endif

#if defined(SWIGPYTHON_BUILTIN) && defined(SWIG_HEAPTYPES)
/* SWIG_HEAPTYPES is not ready for use with SWIGPYTHON_BUILTIN, but if turned on manually requires the following */
#if PY_VERSION_HEX >= 0x03030000 && PY_VERSION_HEX < 0x030c0000
#include <structmember.h>
#define Py_READONLY READONLY
#define Py_T_PYSSIZET T_PYSSIZET
#endif
#endif

#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif

#include <stdio.h>
#include <stdlib.h>

/* -----------------------------------------------------------------------------
 * 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
#define SWIG_POINTER_CLEAR         0x8
#define SWIG_POINTER_RELEASE       (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)

/* 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 returning 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)
/* Runtime errors are < 0 */
#define SWIG_ERROR                 (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)

#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 temporary 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 object 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(const 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.  Choose the last
     name. It should be the most specific; a fully resolved name
     but not necessarily with default template parameters expanded. */
  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

/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#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 _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)

#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


/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */
SWIGINTERN const char *
SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
{
#if PY_VERSION_HEX >= 0x03030000
# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
  *pbytes = NULL;
  return PyUnicode_AsUTF8AndSize(str, psize);
# else
  const char *chars;
  *pbytes = PyUnicode_AsUTF8String(str);
  chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL;
  if (chars && psize)
    *psize = PyBytes_Size(*pbytes);
  return chars;
# endif
#else
  char *chars = NULL;
  *pbytes = NULL;
  PyString_AsStringAndSize(str, &chars, psize);
  return chars;
#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
}

/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_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

#ifdef Py_LIMITED_API
# define PyTuple_GET_ITEM PyTuple_GetItem
/* Note that PyTuple_SetItem() has different semantics from PyTuple_SET_ITEM as it decref's the original tuple item, so in general they cannot be used
  interchangeably. However in SWIG-generated code PyTuple_SET_ITEM is only used with newly initialized tuples without any items and for them this does work. */
# define PyTuple_SET_ITEM PyTuple_SetItem
# define PyTuple_GET_SIZE PyTuple_Size
# define PyCFunction_GET_FLAGS PyCFunction_GetFlags
# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction
# define PyCFunction_GET_SELF PyCFunction_GetSelf
# define PyList_GET_ITEM PyList_GetItem
# define PyList_SET_ITEM PyList_SetItem
# define PySliceObject PyObject
#endif

/* Increment and Decrement wrappers - for portability when using the stable abi and for performance otherwise */
#ifdef Py_LIMITED_API
# define SWIG_Py_INCREF Py_IncRef
# define SWIG_Py_XINCREF Py_IncRef
# define SWIG_Py_DECREF Py_DecRef
# define SWIG_Py_XDECREF Py_DecRef
#else
# define SWIG_Py_INCREF Py_INCREF
# define SWIG_Py_XINCREF Py_XINCREF
# define SWIG_Py_DECREF Py_DECREF
# define SWIG_Py_XDECREF Py_XDECREF
#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;
  case SWIG_NullReferenceError:
    type = PyExc_TypeError;
    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);
    PyObject *bytes = NULL;
    const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
    PyErr_Clear();
    SWIG_Py_XINCREF(type);
    if (tmp)
      PyErr_Format(type, "%s %s", tmp, mesg);
    else
      PyErr_Format(type, "%s", mesg);
    SWIG_Py_XDECREF(bytes);
    SWIG_Py_DECREF(old_str);
    SWIG_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
    if (newvalue) {
      SWIG_Py_XDECREF(value);
      PyErr_Restore(type, newvalue, traceback);
    } else {
      PyErr_Restore(type, value, 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 */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      if PY_VERSION_HEX < 0x03070000
#        define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
#      else
#        define SWIG_PYTHON_INITIALIZE_THREADS
#      endif
#    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) { status = false; PyEval_RestoreThread(save); }}
         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 < 0x03030000
# error "This version of SWIG only supports Python 3 >= 3.3"
#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);
  SWIG_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);
  SWIG_Py_DECREF(s);
}

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  SWIG_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);
  SWIG_Py_DECREF(obj);
}

#endif

/* Append a value to the result obj */

SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj, int is_void) {
  if (!result) {
    result = obj;
  } else if (result == Py_None && is_void) {
    SWIG_Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      if (result) {
        PyList_SET_ITEM(result, 0, o2);
      } else {
        SWIG_Py_DECREF(obj);
        return o2;
      }
    }
    PyList_Append(result,obj);
    SWIG_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;
    }    
  }
}

SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
  int no_kwargs = 1;
  if (kwargs) {
    assert(PyDict_Check(kwargs));
    if (PyDict_Size(kwargs) > 0) {
      PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
      no_kwargs = 0;
    }
  }
  return no_kwargs;
}

/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);

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

#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(PyObject *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(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
#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);
    SWIG_Py_DECREF(str);
    SWIG_Py_DECREF(tail);
    str = joined;
    if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        SWIG_Py_DECREF(str);
        SWIG_Py_DECREF(tail);
        str = joined;
    }
  }
  tail = PyUnicode_InternFromString(")");
  joined = PyUnicode_Concat(str, tail);
  SWIG_Py_DECREF(str);
  SWIG_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(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  swig_globalvar *var = v->vars;
  while (var) {
    swig_globalvar *n = var->next;
    free(var->name);
    free(var);
    var = n;
  }
}

SWIGINTERN PyObject *
swig_varlink_getattr(PyObject *o, char *n) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  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(PyObject *o, char *n, PyObject *p) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  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;
}

#if !defined(SWIGPYTHON_BUILTIN) && PY_VERSION_HEX >= 0x03030000
#define SWIG_HEAPTYPES
#endif

SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
  static char varlink__doc__[] = "Swig var link object";
#ifndef SWIG_HEAPTYPES
  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 */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                       /* tp_print */
#else
      (Py_ssize_t)0,                      /* tp_vectorcall_offset */
#endif
      (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
#if PY_VERSION_HEX >= 0x03080000
      0,                                  /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                  /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                  /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                  /* tp_versions_used */
#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;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)swig_varlink_dealloc },
    { Py_tp_repr, (void *)swig_varlink_repr },
    { Py_tp_getattr, (void *)swig_varlink_getattr },
    { Py_tp_setattr, (void *)swig_varlink_setattr },
    { Py_tp_str, (void *)swig_varlink_str },
    { Py_tp_doc, (void *)varlink__doc__ },
    { 0, NULL }
  };
  PyType_Spec spec = {
    "swigvarlink",
    sizeof(swig_varlinkobject),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  return (PyTypeObject *)PyType_FromSpec(&spec);
#endif
}

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


static PyObject *Swig_Globals_global = NULL;
  
SWIGINTERN PyObject *
SWIG_globals(void) {
  if (Swig_Globals_global == NULL) {
    Swig_Globals_global = SWIG_newvarlink();
  }
  return Swig_Globals_global;
}

#ifdef __cplusplus
}
#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

/* The python void return value */

SWIGRUNTIMEINLINE PyObject * 
SWIG_Py_Void(void)
{
  PyObject *none = Py_None;
  SWIG_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;
    SWIG_Py_INCREF(data->klass);
    /* the newraw method and newargs arguments used to create a new raw instance */
    if (PyClass_Check(obj)) {
      data->newraw = 0;
      SWIG_Py_INCREF(obj);
      data->newargs = obj;
    } else {
      data->newraw = PyObject_GetAttrString(data->klass, "__new__");
      if (data->newraw) {
        data->newargs = PyTuple_New(1);
        if (data->newargs) {
          SWIG_Py_INCREF(obj);
          PyTuple_SET_ITEM(data->newargs, 0, obj);
        } else {
          SWIG_Py_DECREF(data->newraw);
          SWIG_Py_DECREF(data->klass);
          free(data);
          return 0;
        }
      } else {
        SWIG_Py_INCREF(obj);
        data->newargs = obj;
      }
    }
    /* 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) {
      data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 0;
    data->pytype = 0;
    return data;
  }
}

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

/* =============== 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();

  SWIG_Py_XINCREF(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) {
    PyObject *val = SwigPyObject_long(v);
    if (val) {
      PyObject *ofmt;
      PyTuple_SET_ITEM(args, 0, val);
      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
        SWIG_Py_DECREF(ofmt);
      }
    }
    SWIG_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 (repr && v->next) {
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
    if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
      PyObject *joined = PyUnicode_Concat(repr, nrep);
      SWIG_Py_DECREF(repr);
      SWIG_Py_DECREF(nrep);
      repr = joined;
# else
      PyString_ConcatAndDel(&repr,nrep);
# endif
    } else {
      SWIG_Py_DECREF(repr);
      repr = NULL;
    }
  }
  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 = NULL;
  if (!PyErr_Occurred()) {
    if (op != Py_EQ && op != Py_NE) {
      SWIG_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) {
  PyTypeObject *target_tp = SwigPyObject_type();
  PyTypeObject *op_type = Py_TYPE(op);
#ifdef SWIGPYTHON_BUILTIN
  if (PyType_IsSubtype(op_type, target_tp))
    return 1;
  return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
#else
# ifdef Py_LIMITED_API
  int cmp;
  PyObject *tp_name;
#endif
  if (op_type == target_tp)
    return 1;
# ifdef Py_LIMITED_API
  tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
  if (!tp_name)
    return 0;
  cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyObject");
  SWIG_Py_DECREF(tp_name);
  return cmp == 0;
# else
  return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
# endif
#endif
}

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

static PyObject* Swig_Capsule_global = NULL;

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);
        if (tmp) {
          res = SWIG_Python_CallFunctor(destroy, tmp);
        } else {
          res = 0;
        }
        SWIG_Py_XDECREF(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);

      SWIG_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
    SWIG_Py_XDECREF(Swig_Capsule_global);
  }
  SWIG_Py_XDECREF(next);
#ifdef SWIGPYTHON_BUILTIN
  SWIG_Py_XDECREF(sobj->dict);
#endif
  PyObject_Free(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;
  }
  ((SwigPyObject *)next)->next = sobj->next;
  sobj->next = next;
  SWIG_Py_INCREF(next);
  return SWIG_Py_Void();
}

SWIGRUNTIME PyObject* 
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (sobj->next) {    
    SWIG_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)) {
        SWIG_Py_DECREF(SwigPyObject_acquire(v,args));
      } else {
        SWIG_Py_DECREF(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";
#ifndef SWIG_HEAPTYPES
  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 */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /* tp_print */
#else
      (Py_ssize_t)0,                        /* tp_vectorcall_offset */
#endif
      (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
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                    /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                    /* tp_versions_used */
#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;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyObject_dealloc },
    { Py_tp_repr, (void *)SwigPyObject_repr },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)swigobject_doc },
    { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
    { Py_tp_methods, (void *)swigobject_methods },
    { Py_nb_int, (void *)SwigPyObject_long },
    { 0, NULL }
  };
  PyType_Spec spec = {
    "SwigPyObject",
    sizeof(SwigPyObject),
    0,
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
    slots
  };
  return (PyTypeObject *)PyType_FromSpec(&spec);
#endif
}

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;
#ifdef SWIGPYTHON_BUILTIN
    sobj->dict = 0;
#endif
    if (own == SWIG_POINTER_OWN) {
      /* Obtain a reference to the Python capsule wrapping the module information, so that the
       * module information is correctly destroyed after all SWIG python objects have been freed
       * by the GC (and corresponding destructors invoked) */
      SWIG_Py_XINCREF(Swig_Capsule_global);
    }
  }
  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) {
#ifdef Py_LIMITED_API
  int cmp;
  PyObject *tp_name;
#endif
  PyTypeObject* op_type = Py_TYPE(op);
  if (op_type == SwigPyPacked_TypeOnce())
    return 1;
#ifdef Py_LIMITED_API
  tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
  if (!tp_name)
    return 0;
  cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyPacked");
  SWIG_Py_DECREF(tp_name);
  return cmp == 0;
#else
  return (strcmp(op_type->tp_name, "SwigPyPacked") == 0);
#endif
}

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

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
#ifndef SWIG_HEAPTYPES
  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 */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /* tp_print */
#else
      (Py_ssize_t)0,                        /* tp_vectorcall_offset */
#endif
      (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
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                    /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                    /* tp_versions_used */
#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;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyPacked_dealloc },
    { Py_tp_repr, (void *)SwigPyPacked_repr },
    { Py_tp_str, (void *)SwigPyPacked_str },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)swigpacked_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    "SwigPyPacked",
    sizeof(SwigPyPacked),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  return (PyTypeObject *)PyType_FromSpec(&spec);
#endif
}

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_Free((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)) {
#if PY_VERSION_HEX >= 0x030d0000
    PyWeakref_GetRef(pyobj, &pyobj);
    Py_DECREF(pyobj);
#else
    pyobj = PyWeakref_GET_OBJECT(pyobj);
#endif
    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) {
	SWIG_Py_DECREF(obj);
      } else {
	if (PyErr_Occurred()) PyErr_Clear();
	return 0;
      }
    }
  }
#else
  obj = PyObject_GetAttr(pyobj,SWIG_This());
  if (obj) {
    SWIG_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 (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
      res = SWIG_ERROR_RELEASE_NOT_OWNED;
    } else {
      if (own)
        *own = *own | sobj->own;
      if (flags & SWIG_POINTER_DISOWN) {
        sobj->own = 0;
      }
      if (flags & SWIG_POINTER_CLEAR) {
        sobj->ptr = 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);		    
                }
              }
            }
            SWIG_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 */
#ifndef Py_LIMITED_API
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
#else
    PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__");
    PyObject *bytes = NULL;
    const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0;
#endif
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    if (desc)
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
#ifdef Py_LIMITED_API
    SWIG_Py_XDECREF(bytes);
    SWIG_Py_XDECREF(pystr_doc);
#endif
    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;
        }
        if (dict) {
          PyDict_SetItem(dict, SWIG_This(), swig_this);
        } else{
          SWIG_Py_DECREF(inst);
          inst = 0;
        }
      }
#else
      if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
        SWIG_Py_DECREF(inst);
        inst = 0;
      }
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *empty_args = PyTuple_New(0);
    if (empty_args) {
      PyObject *empty_kwargs = PyDict_New();
      if (empty_kwargs) {
#ifndef Py_LIMITED_API
        newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new;
#else
        newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new);
#endif
        inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
        SWIG_Py_DECREF(empty_kwargs);
        if (inst) {
          if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
            SWIG_Py_DECREF(inst);
            inst = 0;
          } else {
            PyType_Modified(Py_TYPE(inst));
          }
        }
      }
      SWIG_Py_DECREF(empty_args);
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      SWIG_Py_DECREF(dict);
    }
#endif
  }
  return inst;
}

SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#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;
    }
    if (dict) {
      return PyDict_SetItem(dict, SWIG_This(), swig_this);
    } else{
      return -1;
    }
  }
#endif
  return PyObject_SetAttr(inst, SWIG_This(), swig_this);
} 


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) {
      SWIG_Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
    } else {
      if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
        return NULL;
    }
    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) {
#ifndef Py_LIMITED_API
        allocfunc alloc = clientdata->pytype->tp_alloc;
#else
        allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc);
#endif
        PyObject *next_self = 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
      if (newobj) {
        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);
    SWIG_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

static PyObject *Swig_TypeCache_global = NULL;

/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
  if (Swig_TypeCache_global == NULL) {
    Swig_TypeCache_global = PyDict_New();
  }
  return Swig_TypeCache_global;
}

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


static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */

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;
  if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */
    return;
  for (i =0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      ty->clientdata = 0;
      if (data) SwigPyClientData_Del(data);
    }
  }
  SWIG_Py_DECREF(SWIG_This());
  Swig_This_global = NULL;
  SWIG_Py_DECREF(SWIG_globals());
  Swig_Globals_global = NULL;
  SWIG_Py_DECREF(SWIG_Python_TypeCache());
  Swig_TypeCache_global = NULL;
  Swig_Capsule_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) {
    if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
      ++interpreter_counter;
      Swig_Capsule_global = pointer;
    } else {
      SWIG_Py_DECREF(pointer);
    }
  } else {
    SWIG_Py_XDECREF(pointer);
  }
}

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);
      if (obj) {
        PyDict_SetItem(cache, key, obj);
        SWIG_Py_DECREF(obj);
      }
    }
  }
  SWIG_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);
      PyObject *bytes = NULL;
      const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
      const char *errmesg = tmp ? tmp : "Invalid error message";
      SWIG_Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, errmesg);
      } else {
	PyErr_Format(type, "%s %s", errmesg, mesg);
      }
      SWIG_Py_XDECREF(bytes);
      SWIG_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)
{
  (void) 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      
    {
#ifndef Py_LIMITED_API
      /* tp_name is not accessible */
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
      if (otype) {
	PyObject *str = PyObject_Str(obj);
	PyObject *bytes = NULL;
	const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 0;
	if (cstr) {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
		       type, otype, cstr);
	} else {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
		       type, otype);
	}
	SWIG_Py_XDECREF(bytes);
	SWIG_Py_XDECREF(str);
	return;
      }
#endif
    }   
    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();
  }
  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 {
    SWIG_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;
      SWIG_Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
      if (!encoded_name)
        goto done;
    }
    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    SWIG_Py_DECREF(encoded_name);
  } else {
    res = f(descr, obj, value);
  }
  
  done:
  SWIG_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) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0) 



  #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_py_mutex.swg
 *
 * contains python mutex for threads
 * ----------------------------------------------------------------------------- */

#if defined(SWIG_PYTHON_THREADS) && !defined(SWIG_THREADS)
#define SWIG_THREADS 1
#endif
#if defined(SWIG_THREADS) && !defined(Py_LIMITED_API)
#include "pythread.h"
#define SWIG_HAVE_MUTEX
namespace Swig {
   class Mutex
   {
       PyThread_type_lock mutex_;
   public:
       Mutex() : mutex_(PyThread_allocate_lock()) {}
       ~Mutex() { PyThread_free_lock(mutex_); }
       void lock() { PyThread_acquire_lock(mutex_, WAIT_LOCK); }
       void unlock() { PyThread_release_lock(mutex_); }
   };
}
#endif
/* -----------------------------------------------------------------------------
 * director_guard.swg
 *
 * Generic Mutex implementation for directors
 *
 * Before including this file, there are two macros to define for choosing
 * an implementation as follows:
 * - SWIG_THREADS:
 *   If defined than mutexes are used.
 *   If not defined then mutexes are not used.
 * - SWIG_HAVE_MUTEX:
 *   If there is a target language defined 'Mutex' class available, the target
 *     language will define this macro to use the class over the options below.
 *     The language 'Mutex' class needs to be Basic Lockable.
 *     It must have public 'void lock()' and 'void unlock()' methods.
 *     See: https://en.cppreference.com/w/cpp/named_req/BasicLockable
 *   If the macro is not defined, one of the following will be used in this order:
 *   - std::mutex if using C++11 or later.
 *   - CRITICAL_SECTION on Windows.
 *   - POSIX pthread mutex.
 * ----------------------------------------------------------------------------- */

#ifdef SWIG_THREADS

#if __cplusplus >= 201103L
/*
 * C++ 11 or above
 * std::mutex        https://en.cppreference.com/w/cpp/thread/mutex
 * std::unique_lock  https://en.cppreference.com/w/cpp/thread/unique_lock
 */
#include <mutex>
#ifdef SWIG_HAVE_MUTEX
/* Use Language defined Mutex class */
#define SWIG_GUARD(_mutex) std::unique_lock<Mutex> _guard(_mutex)
#define SWIG_GUARD_DEFINITION(_cls, _mutex) Mutex _cls::_mutex
#define SWIG_GUARD_DECLARATION(_mutex) static Mutex _mutex
#else
#define SWIG_GUARD(_mutex) std::unique_lock<std::mutex> _guard(_mutex)
#define SWIG_GUARD_DEFINITION(_cls, _mutex) std::mutex _cls::_mutex
#define SWIG_GUARD_DECLARATION(_mutex) static std::mutex _mutex
#endif

#else /* __cplusplus */

#ifdef SWIG_HAVE_MUTEX
/* Use Language defined Mutex class */

#elif defined(_WIN32)
/*
 * Windows Critical Section Objects
 * https://learn.microsoft.com/en-us/windows/win32/Sync/critical-section-objects
 */
#include <windows.h>
#include <synchapi.h>
namespace Swig {
    class Mutex {
        CRITICAL_SECTION mutex_;
    public:
        Mutex() { InitializeCriticalSection(&mutex_); }
        ~Mutex() { DeleteCriticalSection(&mutex_); }
        void lock() { EnterCriticalSection(&mutex_); }
        void unlock() { LeaveCriticalSection(&mutex_); }
    };
}

#else /* _WIN32 */
/*
 * POSIX Thread mutex
 * https://pubs.opengroup.org/onlinepubs/7908799/xsh/pthread.h.html
 */
#include <pthread.h>
namespace Swig {
    class Mutex {
        pthread_mutex_t mutex_;
    public:
        Mutex() { pthread_mutex_init(&mutex_, NULL); }
        ~Mutex() { pthread_mutex_destroy(&mutex_); }
        void lock() { pthread_mutex_lock(&mutex_); }
        void unlock() { pthread_mutex_unlock(&mutex_); }
    };
}

#endif /* _WIN32 */

namespace Swig {
    class Unique_lock {
        Mutex &mutex_;
    public:
        Unique_lock(Mutex &_mutex) : mutex_(_mutex) { mutex_.lock(); }
        ~Unique_lock() { mutex_.unlock(); }
    };
}
#define SWIG_GUARD(_mutex) Unique_lock _guard(_mutex)
#define SWIG_GUARD_DEFINITION(_cls, _mutex) Mutex _cls::_mutex
#define SWIG_GUARD_DECLARATION(_mutex) static Mutex _mutex

#endif /* __cplusplus */

#else /* SWIG_THREADS */

#define SWIG_GUARD(_mutex)
#define SWIG_GUARD_DEFINITION(_cls, _mutex)
#define SWIG_GUARD_DECLARATION(_mutex)

#endif /* SWIG_THREADS */
/* -----------------------------------------------------------------------------
 * 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, swig_msg.c_str());
      }
      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);
    }
  };

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



  /* 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;
        SWIG_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) {
        SWIG_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;
    SWIG_GUARD_DECLARATION(swig_mutex_own);

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

  SWIG_GUARD_DEFINITION(Director, swig_mutex_own);
}

#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_Handler swig_types[3]
#define SWIGTYPE_p_HandlerSafe swig_types[4]
#define SWIGTYPE_p_IDGenerator swig_types[5]
#define SWIGTYPE_p_InformationTheory swig_types[6]
#define SWIGTYPE_p_IsMissing swig_types[7]
#define SWIGTYPE_p_JunctionTreeGenerator swig_types[8]
#define SWIGTYPE_p_MissingValType swig_types[9]
#define SWIGTYPE_p_NodeConstIterator swig_types[10]
#define SWIGTYPE_p_NodeConstIteratorSafe swig_types[11]
#define SWIGTYPE_p_NodeIterator swig_types[12]
#define SWIGTYPE_p_NodeIteratorSafe swig_types[13]
#define SWIGTYPE_p_PRMexplorer swig_types[14]
#define SWIGTYPE_p_PythonApproximationListener swig_types[15]
#define SWIGTYPE_p_PythonBNListener swig_types[16]
#define SWIGTYPE_p_PythonDatabaseGeneratorListener swig_types[17]
#define SWIGTYPE_p_PythonLoadListener swig_types[18]
#define SWIGTYPE_p_allocator_type swig_types[19]
#define SWIGTYPE_p_char swig_types[20]
#define SWIGTYPE_p_difference_type swig_types[21]
#define SWIGTYPE_p_first_type swig_types[22]
#define SWIGTYPE_p_gum__AbstractScheduleMultiDim swig_types[23]
#define SWIGTYPE_p_gum__ApproximationScheme swig_types[24]
#define SWIGTYPE_p_gum__Arc swig_types[25]
#define SWIGTYPE_p_gum__ArcGraphPart swig_types[26]
#define SWIGTYPE_p_gum__ArgumentError swig_types[27]
#define SWIGTYPE_p_gum__BNdistanceT_double_t swig_types[28]
#define SWIGTYPE_p_gum__BayesNetFragmentT_double_t swig_types[29]
#define SWIGTYPE_p_gum__BayesNetT_double_t swig_types[30]
#define SWIGTYPE_p_gum__CPTError swig_types[31]
#define SWIGTYPE_p_gum__CliqueGraph swig_types[32]
#define SWIGTYPE_p_gum__DAG swig_types[33]
#define SWIGTYPE_p_gum__DAGmodel swig_types[34]
#define SWIGTYPE_p_gum__DatabaseError swig_types[35]
#define SWIGTYPE_p_gum__DefaultInLabel swig_types[36]
#define SWIGTYPE_p_gum__DiGraph swig_types[37]
#define SWIGTYPE_p_gum__DiGraphListener swig_types[38]
#define SWIGTYPE_p_gum__DiscreteVariable swig_types[39]
#define SWIGTYPE_p_gum__DiscretizedVariableT_double_t swig_types[40]
#define SWIGTYPE_p_gum__DuplicateElement swig_types[41]
#define SWIGTYPE_p_gum__DuplicateLabel swig_types[42]
#define SWIGTYPE_p_gum__DuplicateScheduleMultiDim swig_types[43]
#define SWIGTYPE_p_gum__Edge swig_types[44]
#define SWIGTYPE_p_gum__EdgeGraphPart swig_types[45]
#define SWIGTYPE_p_gum__EssentialGraph swig_types[46]
#define SWIGTYPE_p_gum__ExactBNdistanceT_double_t swig_types[47]
#define SWIGTYPE_p_gum__Exception swig_types[48]
#define SWIGTYPE_p_gum__FactoryError swig_types[49]
#define SWIGTYPE_p_gum__FactoryInvalidState swig_types[50]
#define SWIGTYPE_p_gum__FatalError swig_types[51]
#define SWIGTYPE_p_gum__FormatNotFound swig_types[52]
#define SWIGTYPE_p_gum__GibbsBNdistanceT_double_t swig_types[53]
#define SWIGTYPE_p_gum__GibbsSamplingT_double_t swig_types[54]
#define SWIGTYPE_p_gum__GraphError swig_types[55]
#define SWIGTYPE_p_gum__GraphicalModel swig_types[56]
#define SWIGTYPE_p_gum__IApproximationSchemeConfiguration swig_types[57]
#define SWIGTYPE_p_gum__IBayesNetT_double_t swig_types[58]
#define SWIGTYPE_p_gum__IDiscretizedVariable swig_types[59]
#define SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t swig_types[60]
#define SWIGTYPE_p_gum__IOError swig_types[61]
#define SWIGTYPE_p_gum__ImportanceSamplingT_double_t swig_types[62]
#define SWIGTYPE_p_gum__IncompatibleEvidence swig_types[63]
#define SWIGTYPE_p_gum__IncompatibleScorePrior swig_types[64]
#define SWIGTYPE_p_gum__InfluenceDiagramT_double_t swig_types[65]
#define SWIGTYPE_p_gum__Instantiation swig_types[66]
#define SWIGTYPE_p_gum__IntegerVariable swig_types[67]
#define SWIGTYPE_p_gum__InvalidArc swig_types[68]
#define SWIGTYPE_p_gum__InvalidArgument swig_types[69]
#define SWIGTYPE_p_gum__InvalidArgumentsNumber swig_types[70]
#define SWIGTYPE_p_gum__InvalidDirectedCycle swig_types[71]
#define SWIGTYPE_p_gum__InvalidEdge swig_types[72]
#define SWIGTYPE_p_gum__InvalidNode swig_types[73]
#define SWIGTYPE_p_gum__InvalidPartiallyDirectedCycle swig_types[74]
#define SWIGTYPE_p_gum__IteratorError swig_types[75]
#define SWIGTYPE_p_gum__LabelizedVariable swig_types[76]
#define SWIGTYPE_p_gum__LazyPropagationT_double_t swig_types[77]
#define SWIGTYPE_p_gum__LearningError swig_types[78]
#define SWIGTYPE_p_gum__ListConstIteratorSafeT_Debug_t swig_types[79]
#define SWIGTYPE_p_gum__ListConstIteratorT_Debug_t swig_types[80]
#define SWIGTYPE_p_gum__Listener swig_types[81]
#define SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t swig_types[82]
#define SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t swig_types[83]
#define SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t swig_types[84]
#define SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t swig_types[85]
#define SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t swig_types[86]
#define SWIGTYPE_p_gum__MarkovBlanket swig_types[87]
#define SWIGTYPE_p_gum__MarkovRandomFieldT_double_t swig_types[88]
#define SWIGTYPE_p_gum__MeekRules swig_types[89]
#define SWIGTYPE_p_gum__MissingValueInDatabase swig_types[90]
#define SWIGTYPE_p_gum__MissingVariableInDatabase swig_types[91]
#define SWIGTYPE_p_gum__MixedGraph swig_types[92]
#define SWIGTYPE_p_gum__MonteCarloSamplingT_double_t swig_types[93]
#define SWIGTYPE_p_gum__MultiDimAdressable swig_types[94]
#define SWIGTYPE_p_gum__MultiDimArrayT_double_t swig_types[95]
#define SWIGTYPE_p_gum__MultiDimContainerT_double_t swig_types[96]
#define SWIGTYPE_p_gum__MultiDimDecoratorT_double_t swig_types[97]
#define SWIGTYPE_p_gum__MultiDimImplementationT_double_t swig_types[98]
#define SWIGTYPE_p_gum__MultiDimInterface swig_types[99]
#define SWIGTYPE_p_gum__MultiDimWithOffsetT_double_t swig_types[100]
#define SWIGTYPE_p_gum__NoChild swig_types[101]
#define SWIGTYPE_p_gum__NoNeighbour swig_types[102]
#define SWIGTYPE_p_gum__NoParent swig_types[103]
#define SWIGTYPE_p_gum__NodeGraphPart swig_types[104]
#define SWIGTYPE_p_gum__NodePropertyT_std__size_t_t swig_types[105]
#define SWIGTYPE_p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_t_t_t swig_types[106]
#define SWIGTYPE_p_gum__NotFound swig_types[107]
#define SWIGTYPE_p_gum__NotImplementedYet swig_types[108]
#define SWIGTYPE_p_gum__NullElement swig_types[109]
#define SWIGTYPE_p_gum__NumericalDiscreteVariable swig_types[110]
#define SWIGTYPE_p_gum__OperationNotAllowed swig_types[111]
#define SWIGTYPE_p_gum__OutOfBounds swig_types[112]
#define SWIGTYPE_p_gum__PDAG swig_types[113]
#define SWIGTYPE_p_gum__PRMTypeError swig_types[114]
#define SWIGTYPE_p_gum__PossiblyIncompatibleScorePrior swig_types[115]
#define SWIGTYPE_p_gum__RangeVariable swig_types[116]
#define SWIGTYPE_p_gum__ScheduleMultiDimError swig_types[117]
#define SWIGTYPE_p_gum__ScheduleOperationError swig_types[118]
#define SWIGTYPE_p_gum__ScheduledInference swig_types[119]
#define SWIGTYPE_p_gum__SequenceT_gum__DiscreteVariable_const_p_t swig_types[120]
#define SWIGTYPE_p_gum__SequenceT_std__size_t_t swig_types[121]
#define SWIGTYPE_p_gum__SetIteratorSafeT_int_t swig_types[122]
#define SWIGTYPE_p_gum__SetIteratorT_int_t swig_types[123]
#define SWIGTYPE_p_gum__SetT_gum__Arc_t swig_types[124]
#define SWIGTYPE_p_gum__SetT_gum__Arc_t__const_iterator swig_types[125]
#define SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t swig_types[126]
#define SWIGTYPE_p_gum__SetT_gum__Edge_t swig_types[127]
#define SWIGTYPE_p_gum__SetT_gum__Edge_t__const_iterator swig_types[128]
#define SWIGTYPE_p_gum__SetT_std__size_t_t swig_types[129]
#define SWIGTYPE_p_gum__SetT_std__size_t_t__const_iterator swig_types[130]
#define SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t swig_types[131]
#define SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t swig_types[132]
#define SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t swig_types[133]
#define SWIGTYPE_p_gum__SizeError swig_types[134]
#define SWIGTYPE_p_gum__StructuralComparator swig_types[135]
#define SWIGTYPE_p_gum__SyntaxError swig_types[136]
#define SWIGTYPE_p_gum__TensorT_double_t swig_types[137]
#define SWIGTYPE_p_gum__ThreadNumberManager swig_types[138]
#define SWIGTYPE_p_gum__Triangulation swig_types[139]
#define SWIGTYPE_p_gum__TypeError swig_types[140]
#define SWIGTYPE_p_gum__UGmodel swig_types[141]
#define SWIGTYPE_p_gum__UnavailableScheduleOperation swig_types[142]
#define SWIGTYPE_p_gum__UndefinedElement swig_types[143]
#define SWIGTYPE_p_gum__UndefinedIteratorKey swig_types[144]
#define SWIGTYPE_p_gum__UndefinedIteratorValue swig_types[145]
#define SWIGTYPE_p_gum__UndiGraph swig_types[146]
#define SWIGTYPE_p_gum__UnexecutedScheduleOperation swig_types[147]
#define SWIGTYPE_p_gum__UnknownLabelInDatabase swig_types[148]
#define SWIGTYPE_p_gum__UnknownScheduleMultiDim swig_types[149]
#define SWIGTYPE_p_gum__UnknownScheduleOperation swig_types[150]
#define SWIGTYPE_p_gum__Variable swig_types[151]
#define SWIGTYPE_p_gum__VariableEliminationT_double_t swig_types[152]
#define SWIGTYPE_p_gum__VariableNodeMap swig_types[153]
#define SWIGTYPE_p_gum__WeightedSamplingT_double_t swig_types[154]
#define SWIGTYPE_p_gum__WrongClassElement swig_types[155]
#define SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t swig_types[156]
#define SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_t swig_types[157]
#define SWIGTYPE_p_gum__credal__CredalNetT_double_t swig_types[158]
#define SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t swig_types[159]
#define SWIGTYPE_p_gum__learning__BNLearnerT_double_t swig_types[160]
#define SWIGTYPE_p_gum__learning__DatabaseTable swig_types[161]
#define SWIGTYPE_p_gum__learning__IBNLearner swig_types[162]
#define SWIGTYPE_p_iterator swig_types[163]
#define SWIGTYPE_p_iterator_category swig_types[164]
#define SWIGTYPE_p_iterator_safe swig_types[165]
#define SWIGTYPE_p_msg swig_types[166]
#define SWIGTYPE_p_node_const_iterator swig_types[167]
#define SWIGTYPE_p_node_const_iterator_safe swig_types[168]
#define SWIGTYPE_p_node_iterator swig_types[169]
#define SWIGTYPE_p_node_iterator_safe swig_types[170]
#define SWIGTYPE_p_p_PyObject swig_types[171]
#define SWIGTYPE_p_second_type swig_types[172]
#define SWIGTYPE_p_size_type swig_types[173]
#define SWIGTYPE_p_std__allocatorT_double_t swig_types[174]
#define SWIGTYPE_p_std__allocatorT_int_t swig_types[175]
#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[176]
#define SWIGTYPE_p_std__allocatorT_unsigned_int_t swig_types[177]
#define SWIGTYPE_p_std__exception swig_types[178]
#define SWIGTYPE_p_std__functionT_double_fdoubleF_t swig_types[179]
#define SWIGTYPE_p_std__functionT_double_fdouble_doubleF_t swig_types[180]
#define SWIGTYPE_p_std__functionT_double_fgum__Instantiation_const_RF_t swig_types[181]
#define SWIGTYPE_p_std__invalid_argument swig_types[182]
#define SWIGTYPE_p_std__mt19937 swig_types[183]
#define SWIGTYPE_p_std__pairT_gum__Instantiation_double_t swig_types[184]
#define SWIGTYPE_p_std__size_t swig_types[185]
#define SWIGTYPE_p_std__string swig_types[186]
#define SWIGTYPE_p_std__vectorT_PythonLoadListener_std__allocatorT_PythonLoadListener_t_t swig_types[187]
#define SWIGTYPE_p_std__vectorT_double_t swig_types[188]
#define SWIGTYPE_p_std__vectorT_gum__DiscreteVariable_const_p_std__allocatorT_gum__DiscreteVariable_const_p_t_t swig_types[189]
#define SWIGTYPE_p_std__vectorT_gum__SetT_std__size_t_t_std__allocatorT_gum__SetT_std__size_t_t_t_t swig_types[190]
#define SWIGTYPE_p_std__vectorT_int_t swig_types[191]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__size_t_std__size_t_t_std__allocatorT_std__pairT_std__size_t_std__size_t_t_t_t swig_types[192]
#define SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t swig_types[193]
#define SWIGTYPE_p_std__vectorT_std__string_t swig_types[194]
#define SWIGTYPE_p_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t swig_types[195]
#define SWIGTYPE_p_std__vectorT_std__vectorT_std__string_t_std__allocatorT_std__vectorT_std__string_t_t_t swig_types[196]
#define SWIGTYPE_p_std__vectorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_t_t swig_types[197]
#define SWIGTYPE_p_std__vectorT_unsigned_int_t swig_types[198]
#define SWIGTYPE_p_swig__SwigPyIterator swig_types[199]
#define SWIGTYPE_p_value_type swig_types[200]
#define SWIGTYPE_p_void swig_types[201]
static swig_type_info *swig_types[203];
static swig_module_info swig_module = {swig_types, 202, 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

#ifdef __cplusplus
#include <utility>
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigSmartPointer {
    T *ptr;
    SwigSmartPointer(T *p) : ptr(p) { }
    ~SwigSmartPointer() { delete ptr; }
    SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
    void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
#if __cplusplus >=201103L
  SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
  operator T&&() const { return std::move(*pointer.ptr); }
#else
  operator T&() const { return *pointer.ptr; }
#endif
  T *operator&() const { return pointer.ptr; }
  static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
};

/*
 * SwigValueInit() is a generic initialisation solution as the following approach:
 * 
 *       T c_result = T();
 * 
 * doesn't compile for all types for example:
 * 
 *       unsigned int c_result = unsigned int();
 */
template <typename T> T SwigValueInit() {
  return T();
}

#if __cplusplus >=201103L
# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
#else
# define SWIG_STD_MOVE(OBJ) OBJ
#endif

#endif


#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;
      SWIG_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;
        SWIG_Py_XINCREF(_obj);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XINCREF(item._obj);
      SWIG_Py_XDECREF(_obj);
      _obj = item._obj;
      SWIG_PYTHON_THREAD_END_BLOCK;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_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)
    {
      SWIG_Py_XDECREF(_obj);
      _obj = obj;
      return *this;      
    }
  };
}


#include <iostream>

#if PY_VERSION_HEX >= 0x03020000
# define SWIGPY_SLICEOBJECT PyObject
#else
# define SWIGPY_SLICEOBJECT PySliceObject
#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 swig_type_info* desc = SWIG_TypeQuery("swig::SwigPyIterator *");
      return desc;
    }    
  };

#if defined(SWIGPYTHON_BUILTIN)
  inline PyObject* make_output_iterator_builtin (PyObject *pyself)
  {
    SWIG_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 <errno.h>


#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, cx, rd;
   errno = 0;
   fx = floor(x);
   cx = ceil(x);
   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));
      // Largest double not larger than ULONG_MAX (not portably calculated easily)
      // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long)
      // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0))
      const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX;
      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));
      // Largest double not larger than LONG_MAX (not portably calculated easily)
      // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long)
      // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0))
      const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX;
      // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN
      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>


#include <utility>


#include "extensions/helpers.h"


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

static void SetPythonizeAgrumException() {
  try {
    throw;
  }
  catch ( std::bad_cast& ) {
    PyErr_SetString ( PyExc_RuntimeError, "C++ Bad Cast" );
  }
  catch (gum::SyntaxError & e) {
    PyErr_SetString ( PyExc_SyntaxError, e.errorContent().c_str());
    PyErr_SyntaxLocationEx(e.filename().c_str(), e.line(), e.col());
  }
  PYGUM_CATCH(DefaultInLabel)
  PYGUM_CATCH(DuplicateElement)
  PYGUM_CATCH(DuplicateLabel)
  PYGUM_CATCH(FatalError)
  PYGUM_CATCH(FormatNotFound)
  PYGUM_CATCH(InvalidArc)
  PYGUM_CATCH(InvalidArgument)
  PYGUM_CATCH(InvalidArgumentsNumber)
  PYGUM_CATCH(InvalidDirectedCycle)
  PYGUM_CATCH(InvalidEdge)
  PYGUM_CATCH(InvalidNode)
  PYGUM_CATCH(DatabaseError)
  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(OutOfBounds)
  PYGUM_CATCH(ArgumentError)
  PYGUM_CATCH(SizeError)
  PYGUM_CATCH(IOError)
  PYGUM_CATCH(UndefinedElement)
  PYGUM_CATCH(UndefinedIteratorKey)
  PYGUM_CATCH(UndefinedIteratorValue)
  PYGUM_CATCH(UnknownLabelInDatabase)
  PYGUM_CATCH(CPTError)
  catch ( std::exception& e ) {
    PyErr_SetString ( PyExc_Exception, e.what() );
  }
}


#include "extensions/JunctionTreeGenerator.h"


#include <agrum/base.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) {
      int res = SWIG_ERROR;
      swig_type_info *descriptor = type_info<Type>();
      if (val) {
        Type *p = 0;
        int newmem = 0;
        res = descriptor ? SWIG_ConvertPtrAndOwn(obj, (void **)&p, descriptor, 0, &newmem) : SWIG_ERROR;
        if (SWIG_IsOK(res)) {
          if (newmem & SWIG_CAST_NEW_MEMORY) {
            res |= SWIG_NEWOBJMASK;
          }
          *val = p;
        }
      } else {
        res = descriptor ? SWIG_ConvertPtr(obj, 0, descriptor, 0) : SWIG_ERROR;
      }
      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);
  }
}


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

}


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


#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) {
      SWIG_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];
          PyOS_snprintf(msg, sizeof(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];
        PyOS_snprintf(msg, sizeof(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--;
      }
    }
  }
}


namespace swig {
  template <class Seq, class T = typename Seq::value_type >
  struct IteratorProtocol {
    static void assign(PyObject *obj, Seq *seq) {
      SwigVar_PyObject iter = PyObject_GetIter(obj);
      if (iter) {
        SwigVar_PyObject item = PyIter_Next(iter);
        while (item) {
          seq->insert(seq->end(), swig::as<T>(item));
          item = PyIter_Next(iter);
        }
      }
    }

    static bool check(PyObject *obj) {
      bool ret = false;
      SwigVar_PyObject iter = PyObject_GetIter(obj);
      if (iter) {
        SwigVar_PyObject item = PyIter_Next(iter);
        ret = true;
        while (item) {
          ret = swig::check<T>(item);
          item = ret ? PyIter_Next(iter) : 0;
        }
      }
      return ret;
    }
  };

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

    static bool is_iterable(PyObject *obj) {
      SwigVar_PyObject iter = PyObject_GetIter(obj);
      PyErr_Clear();
      return iter != 0;
    }

    static int asptr(PyObject *obj, sequence **seq) {
      int ret = SWIG_ERROR;
      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 (is_iterable(obj)) {
	try {
	  if (seq) {
	    *seq = new sequence();
            IteratorProtocol<Seq, T>::assign(obj, *seq);
            if (!PyErr_Occurred())
              return SWIG_NEWOBJ;
	  } else {
	    return IteratorProtocol<Seq, T>::check(obj) ? SWIG_OK : SWIG_ERROR;
	  }
	} catch (std::exception& e) {
          if (seq && !PyErr_Occurred())
            PyErr_SetString(PyExc_TypeError, e.what());
	}
        if (seq)
          delete *seq;
	return SWIG_ERROR;
      }
      return ret;
    }
  };

  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,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(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,SWIGPY_SLICEOBJECT *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(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,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(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,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(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));
    }

namespace swig {
  static PyObject* container_owner_attribute() {
    static PyObject* attr = SWIG_Python_str_FromChar("__swig_container");
    return attr;
  }

  template <typename T>
  struct container_owner {
    // By default, do not add the back-reference (for value types)
    // Specialization below will check the reference for pointer types.
    static bool back_reference(PyObject* /*child*/, PyObject* /*owner*/) {
      return false;
    }
  };

  template <>
  struct container_owner<swig::pointer_category> {  
    /*
     * Call to add a back-reference to the owning object when returning a 
     * reference from a container.  Will only set the reference if child
     * is a SWIG wrapper object that does not own the pointer.
     *
     * returns whether the reference was set or not
     */
    static bool back_reference(PyObject* child, PyObject* owner) {
      SwigPyObject* swigThis = SWIG_Python_GetSwigThis(child);
      if (swigThis && (swigThis->own & SWIG_POINTER_OWN) != SWIG_POINTER_OWN) {
        return PyObject_SetAttr(child, container_owner_attribute(), owner) != -1;
      }
      return false;
    }
  };
}

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,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(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,SWIGPY_SLICEOBJECT *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(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,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(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,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(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_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);
}


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


      namespace swig {
	template <>  struct traits<std::vector< int, std::allocator< int > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "int" "," "std::allocator< int >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
      return self->size();
    }
SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
    }
SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< int,std::allocator< int > >::difference_type id = i;
      std::vector< int,std::allocator< int > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice,std::vector< int,std::allocator< int > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< int,std::allocator< int > >::difference_type id = i;
      std::vector< int,std::allocator< int > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< int,std::allocator< int > >::difference_type id = i;
      std::vector< int,std::allocator< int > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< int,std::allocator< int > >::difference_type id = i;
      std::vector< int,std::allocator< int > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem____SWIG_1(std::vector< int > const *self,std::vector< int >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_2(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< int,std::allocator< int > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_1(std::vector< int > *self,std::vector< int >::iterator first,std::vector< int >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__insert__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::size_type n,std::vector< int >::value_type const &x){ self->insert(pos, n, x); }

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


/* Return string from Python obj. NOTE: obj must remain in scope in order
   to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */
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;
    PyObject *bytes = NULL;
    int ret = SWIG_OK;
    if (alloc)
      *alloc = SWIG_OLDOBJ;
#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
      return SWIG_TypeError;
#else
    cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes);
    if (!cstr)
      return SWIG_TypeError;
    /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */
    if (bytes && cptr) {
      if (alloc) {
        cstr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        *alloc = SWIG_NEWOBJ;
      } else {
        /* alloc must be set in order to clean up allocated memory */
        return SWIG_RuntimeError;
      }
    }
#endif
    if (cptr) *cptr = cstr;
    if (psize) *psize = len + 1;
    SWIG_Py_XDECREF(bytes);
    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;

        SWIG_Py_XDECREF(obj);
        return SWIG_OK;
      } else {
        SWIG_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 {
    PyErr_Clear();
    static swig_type_info *descriptor = SWIG_TypeQuery("std::string" " *");
    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;
}


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,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(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,SWIGPY_SLICEOBJECT *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(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,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(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,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(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); }

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

SWIGINTERN std::string gum_DiscreteVariable___repr__(gum::DiscreteVariable const *self){
   std::stringstream s;
   s<<"(pyagrum.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_asLabelizedVar(gum::DiscreteVariable *self){
    if (self->varType()!=gum::VarType::LABELIZED) {
      GUM_ERROR(gum::OperationNotAllowed,"impossible cast as gum.LabelizedVar for "<<*self);
    }
    return *static_cast<gum::LabelizedVariable * >(self);
  }
SWIGINTERN gum::RangeVariable gum_DiscreteVariable_asRangeVar(gum::DiscreteVariable *self){
    if (self->varType() != gum::VarType::RANGE)
      GUM_ERROR(gum::OperationNotAllowed,"impossible cast as gum.RangeVar for "<<*self);
    return *static_cast<gum::RangeVariable*>(self);
  }
SWIGINTERN gum::IntegerVariable gum_DiscreteVariable_asIntegerVar(gum::DiscreteVariable *self){
    if (self->varType()!=gum::VarType::INTEGER) {
      GUM_ERROR(gum::OperationNotAllowed, "impossible cast as gum.IntegerVar for " << *self);
    }
    return *static_cast<gum::IntegerVariable*>(self );
  }
SWIGINTERN gum::NumericalDiscreteVariable gum_DiscreteVariable_asNumericalDiscreteVar(gum::DiscreteVariable *self){
    if (self->varType()!=gum::VarType::NUMERICAL) {
      GUM_ERROR(gum::OperationNotAllowed, "impossible cast as gum.NumericalDiscreteVar for " << *self);
    }
    return *static_cast<gum::NumericalDiscreteVariable *>(self);
  }
SWIGINTERN gum::DiscretizedVariable< double > gum_DiscreteVariable_asDiscretizedVar(gum::DiscreteVariable *self){
    if (self->varType()!=gum::VarType::DISCRETIZED) {
      GUM_ERROR(gum::OperationNotAllowed, "impossible cast as gum.DiscretizedVar for " << *self);
    }
    return *static_cast<gum::DiscretizedVariable<double> *>(self);
  }
SWIGINTERN std::string gum_LabelizedVariable___repr__(gum::LabelizedVariable const *self){
   std::stringstream s;
   s<<"(pyagrum.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<<"(pyagrum.RangeVariable@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_RangeVariable___str__(gum::RangeVariable const *self){ return self->toString();}

#include <memory>

SWIGINTERN std::string gum_IntegerVariable___repr__(gum::IntegerVariable const *self){
   std::stringstream s;
   s<<"(pyagrum.IntegerVariable@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_IntegerVariable___str__(gum::IntegerVariable const *self){ return self->toString();}
SWIGINTERN std::string gum_NumericalDiscreteVariable___repr__(gum::NumericalDiscreteVariable const *self){
   std::stringstream s;
   s<<"(pyagrum.NumericalDiscreteVariable@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_NumericalDiscreteVariable___str__(gum::NumericalDiscreteVariable const *self){ return self->toString();}

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

SWIGINTERN std::string gum_UndiGraph___repr__(gum::UndiGraph const *self){
   std::stringstream s;
   s<<"(pyagrum.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());
  }
SWIGINTERN PyObject *gum_UndiGraph_addNodes(gum::UndiGraph const *self,gum::Size n){
    PyObject* q=PySet_New(0);

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

    return q;
  }
SWIGINTERN PyObject *gum_UndiGraph_edges(gum::UndiGraph const *self){ // add for the sub-classes (including MixedGraph)
    return PyAgrumHelper::PySetFromEdgeSet(self->edges());
  }
SWIGINTERN PyObject *gum_UndiGraph_neighbours(gum::UndiGraph const *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__SWIG_1(gum::UndiGraph *self,gum::NodeId const n1,gum::NodeId const n2){
    self->addEdge(n1,n2);
  }
SWIGINTERN void gum_UndiGraph_eraseEdge(gum::UndiGraph *self,gum::NodeId const n1,gum::NodeId const n2){
    self->eraseEdge(gum::Edge(n1,n2));
  }
SWIGINTERN bool gum_UndiGraph_existsEdge(gum::UndiGraph const *self,gum::NodeId const n1,gum::NodeId const n2){
    return self->existsEdge(n1,n2);
  }
SWIGINTERN gum::Size gum_UndiGraph_sizeEdges(gum::UndiGraph const *self){
    return self->sizeEdges();
  }
SWIGINTERN bool gum_UndiGraph_emptyEdges(gum::UndiGraph const *self){
    return self->emptyEdges();
  }
SWIGINTERN void gum_UndiGraph_eraseNeighbours(gum::UndiGraph *self,gum::NodeId const n){
    self->eraseNeighbours(n);
  }
SWIGINTERN std::string gum_DiGraph___repr__(gum::DiGraph const *self){
   std::stringstream s;
   s<<"(pyagrum.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());
  }
SWIGINTERN PyObject *gum_DiGraph_addNodes(gum::DiGraph const *self,gum::Size n){
    PyObject* q=PySet_New(0);

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

    return q;
  }
SWIGINTERN PyObject *gum_DiGraph_arcs(gum::DiGraph const *self){ // add for the sub-classes (including MixedGraph and PDAG)
    return PyAgrumHelper::PySetFromArcSet(self->arcs());
  }
SWIGINTERN PyObject *gum_DiGraph_parents(gum::DiGraph const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->parents(id));
  }
SWIGINTERN PyObject *gum_DiGraph_children(gum::DiGraph const *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->addArc(n1,n2);
  }
SWIGINTERN void gum_DiGraph_eraseArc(gum::DiGraph *self,gum::NodeId const n1,gum::NodeId const n2){
    self->eraseArc(gum::Arc(n1,n2));
  }
SWIGINTERN bool gum_DiGraph_existsArc(gum::DiGraph const *self,gum::NodeId const n1,gum::NodeId const n2){
    return self->existsArc(n1,n2);
  }
SWIGINTERN void gum_DiGraph_eraseParents(gum::DiGraph *self,gum::NodeId const n){
    self->eraseParents(n);
  }
SWIGINTERN void gum_DiGraph_eraseChildren(gum::DiGraph *self,gum::NodeId const n){
    self->eraseChildren(n);
  }
SWIGINTERN gum::Size gum_DiGraph_sizeArcs(gum::DiGraph const *self){
    return self->sizeArcs();
  }
SWIGINTERN bool gum_DiGraph_emptyArcs(gum::DiGraph const *self){
    return self->emptyArcs();
  }
SWIGINTERN std::string gum_DAG___repr__(gum::DAG const *self){
   std::stringstream s;
   s<<"(pyagrum.DAG@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_DAG___str__(gum::DAG const *self){ return self->toString();}
SWIGINTERN bool gum_DAG_dSeparation__SWIG_2(gum::DAG *self,PyObject *X,PyObject *Y,PyObject *Z){
     gum::NodeSet sX,sY,sZ;
     PyAgrumHelper::populateNodeSetFromIntOrPySequenceOfInt(sX,X);
     PyAgrumHelper::populateNodeSetFromIntOrPySequenceOfInt(sY,Y);
     PyAgrumHelper::populateNodeSetFromIntOrPySequenceOfInt(sZ,Z);
     return self->dSeparation(sX,sY,sZ);
   }
SWIGINTERN bool gum_DAG_dSeparation__SWIG_3(gum::DAG *self,PyObject *X,PyObject *Y){
     gum::NodeSet sX,sY,sZ;
     PyAgrumHelper::populateNodeSetFromIntOrPySequenceOfInt(sX,X);
     PyAgrumHelper::populateNodeSetFromIntOrPySequenceOfInt(sY,Y);
     return self->dSeparation(sX,sY,sZ);
   }
SWIGINTERN gum::UndiGraph gum_DAG_moralizedAncestralGraph__SWIG_1(gum::DAG *self,PyObject *nodes){
     gum::NodeSet sonodes;
     PyAgrumHelper::populateNodeSetFromIntOrPySequenceOfInt(sonodes,nodes);
     return self->moralizedAncestralGraph(sonodes);
   }
SWIGINTERN PyObject *gum_DAG_addNodes(gum::DAG const *self,gum::Size n){
    PyObject* q=PySet_New(0);

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

    return q;
  }
SWIGINTERN PyObject *gum_DAG_arcs(gum::DAG const *self){ // add for the sub-classes (including MixedGraph and PDAG)
    return PyAgrumHelper::PySetFromArcSet(self->arcs());
  }
SWIGINTERN PyObject *gum_DAG_parents(gum::DAG const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->parents(id));
  }
SWIGINTERN PyObject *gum_DAG_children(gum::DAG const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->children(id));
  }
SWIGINTERN void gum_DAG_addArc__SWIG_1(gum::DAG *self,gum::NodeId const n1,gum::NodeId const n2){
    self->addArc(n1,n2);
  }
SWIGINTERN void gum_DAG_eraseArc(gum::DAG *self,gum::NodeId const n1,gum::NodeId const n2){
    self->eraseArc(gum::Arc(n1,n2));
  }
SWIGINTERN bool gum_DAG_existsArc(gum::DAG const *self,gum::NodeId const n1,gum::NodeId const n2){
    return self->existsArc(n1,n2);
  }
SWIGINTERN void gum_DAG_eraseParents(gum::DAG *self,gum::NodeId const n){
    self->eraseParents(n);
  }
SWIGINTERN void gum_DAG_eraseChildren(gum::DAG *self,gum::NodeId const n){
    self->eraseChildren(n);
  }
SWIGINTERN gum::Size gum_DAG_sizeArcs(gum::DAG const *self){
    return self->sizeArcs();
  }
SWIGINTERN bool gum_DAG_emptyArcs(gum::DAG const *self){
    return self->emptyArcs();
  }
SWIGINTERN std::string gum_MixedGraph___repr__(gum::MixedGraph const *self){
   std::stringstream s;
   s<<"(pyagrum.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_MixedGraph_addNodes(gum::MixedGraph const *self,gum::Size n){
    PyObject* q=PySet_New(0);

    PyObject* pyval;
    for(auto node : const_cast<gum::MixedGraph *>(self)->addNodes(n)) {
      pyval=PyInt_FromLong(node);
      PySet_Add(q,pyval);
      Py_DecRef(pyval);
    }

    return q;
  }
SWIGINTERN PyObject *gum_MixedGraph_arcs(gum::MixedGraph const *self){ // add for the sub-classes (including MixedGraph and PDAG)
    return PyAgrumHelper::PySetFromArcSet(self->arcs());
  }
SWIGINTERN PyObject *gum_MixedGraph_parents(gum::MixedGraph const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->parents(id));
  }
SWIGINTERN PyObject *gum_MixedGraph_children(gum::MixedGraph const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->children(id));
  }
SWIGINTERN PyObject *gum_MixedGraph_edges(gum::MixedGraph const *self){ // add for the sub-classes (including MixedGraph)
    return PyAgrumHelper::PySetFromEdgeSet(self->edges());
  }
SWIGINTERN PyObject *gum_MixedGraph_neighbours(gum::MixedGraph const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->neighbours(id));
  }
SWIGINTERN PyObject *gum_MixedGraph_boundary(gum::MixedGraph const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->boundary(id));
  }
SWIGINTERN PyObject *gum_MixedGraph_mixedOrientedPath(gum::MixedGraph const *self,gum::NodeId node1,gum::NodeId node2){
    return PyAgrumHelper::PyListFromNodeVect(self->mixedOrientedPath(node1,node2));
  }
SWIGINTERN PyObject *gum_MixedGraph_mixedUnorientedPath(gum::MixedGraph const *self,gum::NodeId node1,gum::NodeId node2){
    return PyAgrumHelper::PyListFromNodeVect(self->mixedUnorientedPath(node1,node2));
  }
SWIGINTERN gum::NodeId gum_MixedGraph_addNode(gum::MixedGraph *self){
    return self->gum::NodeGraphPart::addNode();
  }
SWIGINTERN void gum_MixedGraph_addNodeWithId(gum::MixedGraph *self,gum::NodeId const id){
    self->gum::NodeGraphPart::addNodeWithId(id);
  }
SWIGINTERN bool gum_MixedGraph_existsNode(gum::MixedGraph const *self,gum::NodeId const id){
    return self->gum::NodeGraphPart::existsNode(id);
  }
SWIGINTERN gum::Size gum_MixedGraph_size(gum::MixedGraph const *self){
    return self->gum::NodeGraphPart::size();
  }
SWIGINTERN bool gum_MixedGraph_empty(gum::MixedGraph const *self){
    return self->gum::NodeGraphPart::empty();
  }
SWIGINTERN void gum_MixedGraph_addEdge(gum::MixedGraph *self,gum::NodeId const n1,gum::NodeId const n2){
    self->addEdge(n1,n2);
  }
SWIGINTERN void gum_MixedGraph_eraseEdge(gum::MixedGraph *self,gum::NodeId const n1,gum::NodeId const n2){
    self->eraseEdge(gum::Edge(n1,n2));
  }
SWIGINTERN bool gum_MixedGraph_existsEdge(gum::MixedGraph const *self,gum::NodeId const n1,gum::NodeId const n2){
    return self->existsEdge(n1,n2);
  }
SWIGINTERN gum::Size gum_MixedGraph_sizeEdges(gum::MixedGraph const *self){
    return self->sizeEdges();
  }
SWIGINTERN bool gum_MixedGraph_emptyEdges(gum::MixedGraph const *self){
    return self->emptyEdges();
  }
SWIGINTERN void gum_MixedGraph_eraseNeighbours(gum::MixedGraph *self,gum::NodeId const n){
    self->eraseNeighbours(n);
  }
SWIGINTERN void gum_MixedGraph_addArc(gum::MixedGraph *self,gum::NodeId const n1,gum::NodeId const n2){
    self->addArc(n1,n2);
  }
SWIGINTERN void gum_MixedGraph_eraseArc(gum::MixedGraph *self,gum::NodeId const n1,gum::NodeId const n2){
    self->eraseArc(gum::Arc(n1,n2));
  }
SWIGINTERN bool gum_MixedGraph_existsArc(gum::MixedGraph const *self,gum::NodeId const n1,gum::NodeId const n2){
    return self->existsArc(n1,n2);
  }
SWIGINTERN void gum_MixedGraph_eraseParents(gum::MixedGraph *self,gum::NodeId const n){
    self->eraseParents(n);
  }
SWIGINTERN void gum_MixedGraph_eraseChildren(gum::MixedGraph *self,gum::NodeId const n){
    self->eraseChildren(n);
  }
SWIGINTERN gum::Size gum_MixedGraph_sizeArcs(gum::MixedGraph const *self){
    return self->sizeArcs();
  }
SWIGINTERN bool gum_MixedGraph_emptyArcs(gum::MixedGraph const *self){
    return self->emptyArcs();
  }
SWIGINTERN std::string gum_PDAG___repr__(gum::PDAG const *self){
   std::stringstream s;
   s<<"(pyagrum.PDAG@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_PDAG___str__(gum::PDAG const *self){ return self->toString();}
SWIGINTERN bool gum_PDAG_cSeparation__SWIG_2(gum::PDAG *self,PyObject *X,PyObject *Y,PyObject *Z){
     gum::NodeSet sX,sY,sZ;
     PyAgrumHelper::populateNodeSetFromIntOrPySequenceOfInt(sX,X);
     PyAgrumHelper::populateNodeSetFromIntOrPySequenceOfInt(sY,Y);
     PyAgrumHelper::populateNodeSetFromIntOrPySequenceOfInt(sZ,Z);
     return self->cSeparation(sX,sY,sZ);
   }
SWIGINTERN bool gum_PDAG_cSeparation__SWIG_3(gum::PDAG *self,PyObject *X,PyObject *Y){
     gum::NodeSet sX,sY,sZ;
     PyAgrumHelper::populateNodeSetFromIntOrPySequenceOfInt(sX,X);
     PyAgrumHelper::populateNodeSetFromIntOrPySequenceOfInt(sY,Y);
     return self->cSeparation(sX,sY,sZ);
   }
SWIGINTERN gum::UndiGraph gum_PDAG_moralizedAncestralGraph__SWIG_1(gum::PDAG *self,PyObject *nodes){
     gum::NodeSet sonodes;
     PyAgrumHelper::populateNodeSetFromIntOrPySequenceOfInt(sonodes,nodes);
     return self->moralizedAncestralGraph(sonodes);
   }
SWIGINTERN PyObject *gum_PDAG_addNodes(gum::PDAG const *self,gum::Size n){
    PyObject* q=PySet_New(0);

    PyObject* pyval;
    for(auto node : const_cast<gum::PDAG *>(self)->addNodes(n)) {
      pyval=PyInt_FromLong(node);
      PySet_Add(q,pyval);
      Py_DecRef(pyval);
    }

    return q;
  }
SWIGINTERN PyObject *gum_PDAG_arcs(gum::PDAG const *self){ // add for the sub-classes (including MixedGraph and PDAG)
    return PyAgrumHelper::PySetFromArcSet(self->arcs());
  }
SWIGINTERN PyObject *gum_PDAG_parents(gum::PDAG const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->parents(id));
  }
SWIGINTERN PyObject *gum_PDAG_children(gum::PDAG const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->children(id));
  }
SWIGINTERN PyObject *gum_PDAG_edges(gum::PDAG const *self){ // add for the sub-classes (including MixedGraph)
    return PyAgrumHelper::PySetFromEdgeSet(self->edges());
  }
SWIGINTERN PyObject *gum_PDAG_neighbours(gum::PDAG const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->neighbours(id));
  }
SWIGINTERN PyObject *gum_PDAG_boundary(gum::PDAG const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->boundary(id));
  }
SWIGINTERN PyObject *gum_PDAG_mixedOrientedPath(gum::PDAG const *self,gum::NodeId node1,gum::NodeId node2){
    return PyAgrumHelper::PyListFromNodeVect(self->mixedOrientedPath(node1,node2));
  }
SWIGINTERN PyObject *gum_PDAG_mixedUnorientedPath(gum::PDAG const *self,gum::NodeId node1,gum::NodeId node2){
    return PyAgrumHelper::PyListFromNodeVect(self->mixedUnorientedPath(node1,node2));
  }
SWIGINTERN gum::NodeId gum_PDAG_addNode(gum::PDAG *self){
    return self->gum::NodeGraphPart::addNode();
  }
SWIGINTERN void gum_PDAG_addNodeWithId(gum::PDAG *self,gum::NodeId const id){
    self->gum::NodeGraphPart::addNodeWithId(id);
  }
SWIGINTERN bool gum_PDAG_existsNode(gum::PDAG const *self,gum::NodeId const id){
    return self->gum::NodeGraphPart::existsNode(id);
  }
SWIGINTERN gum::Size gum_PDAG_size(gum::PDAG const *self){
    return self->gum::NodeGraphPart::size();
  }
SWIGINTERN bool gum_PDAG_empty(gum::PDAG const *self){
    return self->gum::NodeGraphPart::empty();
  }
SWIGINTERN void gum_PDAG_addEdge__SWIG_1(gum::PDAG *self,gum::NodeId const n1,gum::NodeId const n2){
    self->addEdge(n1,n2);
  }
SWIGINTERN void gum_PDAG_eraseEdge(gum::PDAG *self,gum::NodeId const n1,gum::NodeId const n2){
    self->eraseEdge(gum::Edge(n1,n2));
  }
SWIGINTERN bool gum_PDAG_existsEdge(gum::PDAG const *self,gum::NodeId const n1,gum::NodeId const n2){
    return self->existsEdge(n1,n2);
  }
SWIGINTERN gum::Size gum_PDAG_sizeEdges(gum::PDAG const *self){
    return self->sizeEdges();
  }
SWIGINTERN bool gum_PDAG_emptyEdges(gum::PDAG const *self){
    return self->emptyEdges();
  }
SWIGINTERN void gum_PDAG_eraseNeighbours(gum::PDAG *self,gum::NodeId const n){
    self->eraseNeighbours(n);
  }
SWIGINTERN void gum_PDAG_addArc__SWIG_1(gum::PDAG *self,gum::NodeId const n1,gum::NodeId const n2){
    self->addArc(n1,n2);
  }
SWIGINTERN void gum_PDAG_eraseArc(gum::PDAG *self,gum::NodeId const n1,gum::NodeId const n2){
    self->eraseArc(gum::Arc(n1,n2));
  }
SWIGINTERN bool gum_PDAG_existsArc(gum::PDAG const *self,gum::NodeId const n1,gum::NodeId const n2){
    return self->existsArc(n1,n2);
  }
SWIGINTERN void gum_PDAG_eraseParents(gum::PDAG *self,gum::NodeId const n){
    self->eraseParents(n);
  }
SWIGINTERN void gum_PDAG_eraseChildren(gum::PDAG *self,gum::NodeId const n){
    self->eraseChildren(n);
  }
SWIGINTERN gum::Size gum_PDAG_sizeArcs(gum::PDAG const *self){
    return self->sizeArcs();
  }
SWIGINTERN bool gum_PDAG_emptyArcs(gum::PDAG const *self){
    return self->emptyArcs();
  }
SWIGINTERN PyObject *gum_CliqueGraph_clique(gum::CliqueGraph const *self,gum::NodeId const clique){
    PyObject* q=PySet_New(0);

    PyObject* pyval;
    for(auto node :self->clique(clique)) {
      pyval=PyInt_FromLong(node);
      PySet_Add(q,pyval);
      Py_DecRef(pyval);
    }

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

    PyObject* pyval;
    for(auto node : self->separator(cliq1,cliq2)) {
      pyval=PyInt_FromLong(node);
      PySet_Add(q,pyval);
      Py_DecRef(pyval);
    }

    return q;
  }
SWIGINTERN PyObject *gum_MeekRules_choices(gum::MeekRules const *self){
    PyObject* q=PyList_New(0);

    PyObject* pyval;
    for ( auto arc : self->choices()) {
      pyval=Py_BuildValue("(i,i)", arc.tail(), arc.head());
      PyList_Append(q,pyval);
      Py_DecRef(pyval);
    }
    return q;
  }
SWIGINTERN std::string gum_Instantiation___repr__(gum::Instantiation const *self){
   std::stringstream s;
   s<<"(pyagrum.Instantiation@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_Instantiation___str__(gum::Instantiation const *self){ return self->toString();}
SWIGINTERN void gum_Instantiation_setMutable(gum::Instantiation *self){
    self->forgetMaster();
  }
SWIGINTERN bool gum_Instantiation_isMutable(gum::Instantiation *self){
    return self->isSlave();
  }
SWIGINTERN PyObject *gum_Instantiation_todict__SWIG_0(gum::Instantiation const *self,bool withLabels=false){
    return PyAgrumHelper::instantiationToDict(*self,withLabels);
  }
SWIGINTERN void gum_Instantiation__cppfromdict(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 std::string gum_DiscretizedVariable_Sl_double_Sg____repr__(gum::DiscretizedVariable< double > const *self){
   std::stringstream s;
   s<<"(pyagrum.DiscretizedVariable@"<<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_Tensor_Sl_double_Sg____repr__(gum::Tensor< double > const *self){
   std::stringstream s;
   s<<"(pyagrum.Tensor@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_Tensor_Sl_double_Sg____str__(gum::Tensor< double > const *self){ return self->toString();}
SWIGINTERN PyObject *gum_Tensor_Sl_double_Sg__expectedValue__SWIG_1(gum::Tensor< double > const *self,PyObject *pyfunc){
    if (!PyCallable_Check(pyfunc)) { PyErr_SetString(PyExc_TypeError, "Need a callable object!");return NULL; }

    PyObject* args=PyTuple_New(1);
    double res=self->expectedValue([args,pyfunc](const gum::Instantiation& i) -> double {
      double val;
      PyObject* arg=PyAgrumHelper::instantiationToDict(i,false);
      PyTuple_SetItem(args,0,arg);
      PyObject* pyres=PyObject_Call(pyfunc,args,NULL);
      //314 Py_DecRef(arg);                                                                                                        *
      if (pyres==NULL) {
        val=0;
      } else {
        val=PyFloat_AsDouble(pyres);
        Py_DecRef(pyres);
      }
      return val;
      });

    Py_DecRef(args);
    return PyFloat_FromDouble(res);
  }
SWIGINTERN gum::Tensor< double > gum_Tensor_Sl_double_Sg__extract__SWIG_1(gum::Tensor< double > *self,PyObject *arg){
    if (PyDict_Check(arg)) {
      gum::Instantiation inst;
      PyAgrumHelper::fillInstantiationFromPyObject(self, inst, arg);
      return self->extract(inst);
    } else {
      GUM_ERROR(gum::InvalidArgument,"arg is neither a dict or an pyagrum.Instantiation.");
    }
  }
SWIGINTERN gum::Tensor< double > gum_Tensor_Sl_double_Sg__sumOut__SWIG_1(gum::Tensor< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->sumOut(s);
    }
SWIGINTERN gum::Tensor< double > gum_Tensor_Sl_double_Sg__prodOut__SWIG_1(gum::Tensor< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->prodOut(s);
    }
SWIGINTERN gum::Tensor< double > gum_Tensor_Sl_double_Sg__maxOut__SWIG_1(gum::Tensor< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->maxOut(s);
    }
SWIGINTERN gum::Tensor< double > gum_Tensor_Sl_double_Sg__minOut__SWIG_1(gum::Tensor< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->minOut(s);
    }
SWIGINTERN gum::Tensor< double > gum_Tensor_Sl_double_Sg__sumIn__SWIG_1(gum::Tensor< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->sumIn(s);
    }
SWIGINTERN gum::Tensor< double > gum_Tensor_Sl_double_Sg__prodIn__SWIG_1(gum::Tensor< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->prodIn(s);
    }
SWIGINTERN gum::Tensor< double > gum_Tensor_Sl_double_Sg__maxIn__SWIG_1(gum::Tensor< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->maxIn(s);
    }
SWIGINTERN gum::Tensor< double > gum_Tensor_Sl_double_Sg__minIn__SWIG_1(gum::Tensor< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->minIn(s);
    }
SWIGINTERN PyObject *gum_Tensor_Sl_double_Sg__argmin(gum::Tensor< double > *self){
      const auto [argmi,mi] = self->argmin();
      return PyTuple_Pack(2,PyAgrumHelper::PySeqFromSetOfInstantiation(argmi),PyFloat_FromDouble(mi));
    }
SWIGINTERN PyObject *gum_Tensor_Sl_double_Sg__argmax(gum::Tensor< double > *self){
      const auto [argma,ma] = self->argmax();
      return PyTuple_Pack(2,PyAgrumHelper::PySeqFromSetOfInstantiation(argma),PyFloat_FromDouble(ma));
    }
SWIGINTERN bool gum_Tensor_Sl_double_Sg____eq____SWIG_1(gum::Tensor< double > *self,gum::Tensor< double > const &b){
      return *self==b;
    }
SWIGINTERN bool gum_Tensor_Sl_double_Sg____ne__(gum::Tensor< double > *self,gum::Tensor< double > const &b){
      return *self!=b;
    }
SWIGINTERN double gum_Tensor_Sl_double_Sg__get(gum::Tensor< double > const *self,gum::Instantiation const &i){
    return self->gum::MultiDimDecorator<double>::get(i);
  }
SWIGINTERN void gum_Tensor_Sl_double_Sg__set(gum::Tensor< double > const *self,gum::Instantiation const &i,double const &value){
    self->gum::MultiDimDecorator<double>::set(i,value);
  }
SWIGINTERN bool gum_Tensor_Sl_double_Sg__empty(gum::Tensor< double > const *self){
    return self->gum::MultiDimDecorator<double>::empty();
  }
SWIGINTERN gum::Idx gum_Tensor_Sl_double_Sg__pos(gum::Tensor< double > const *self,gum::DiscreteVariable const &v){
    return self->gum::MultiDimDecorator<double>::pos(v);
  }
SWIGINTERN bool gum_Tensor_Sl_double_Sg__contains(gum::Tensor< double > const *self,gum::DiscreteVariable const &v){
    return self->gum::MultiDimDecorator<double>::contains(v);
  }
SWIGINTERN gum::Idx gum_Tensor_Sl_double_Sg__nbrDim__SWIG_0(gum::Tensor< double > const *self){
    return self->gum::MultiDimDecorator<double>::nbrDim();
  }
SWIGINTERN gum::DiscreteVariable const &gum_Tensor_Sl_double_Sg__variable__SWIG_0(gum::Tensor< double > const *self,gum::Idx i){
    return self->gum::MultiDimDecorator<double>::variable(i);
  }
SWIGINTERN gum::DiscreteVariable const &gum_Tensor_Sl_double_Sg__variable__SWIG_1(gum::Tensor< double > const *self,std::string const &name){
    return self->gum::MultiDimDecorator<double>::variable(name);
  }
SWIGINTERN void gum_Tensor_Sl_double_Sg__remove(gum::Tensor< double > *self,gum::DiscreteVariable const &var){
    self->erase(var);
  }
SWIGINTERN void gum_Tensor_Sl_double_Sg__add(gum::Tensor< double > *self,gum::DiscreteVariable const &v){
    self->gum::MultiDimDecorator<double>::add(v);
  }
SWIGINTERN gum::Size gum_Tensor_Sl_double_Sg__domainSize(gum::Tensor< double > *self){return self->gum::MultiDimDecorator<double>::domainSize();}
SWIGINTERN gum::Size gum_Tensor_Sl_double_Sg__nbrDim__SWIG_1(gum::Tensor< double > *self){return self->gum::MultiDimDecorator<double>::nbrDim();}

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


  namespace swig {


















































    template <class T, class U >
    struct traits_asptr<std::pair<T,U> >  {
      typedef std::pair<T,U> value_type;

      static int get_pair(PyObject* first, PyObject* second,
			  std::pair<T,U> **val) 
      {
	if (val) {
	  value_type *vp = (new std::pair<T,U>());
	  T *pfirst = &(vp->first);
	  int res1 = swig::asval((PyObject*)first, pfirst);
	  if (!SWIG_IsOK(res1)) {
	    delete vp;
	    return res1;
	  }
	  U *psecond = &(vp->second);
	  int res2 = swig::asval((PyObject*)second, psecond);
	  if (!SWIG_IsOK(res2)) {
	    delete vp;
	    return res2;
	  }
	  *val = vp;
	  return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
	} else {
	  T *pfirst = 0;
	  int res1 = swig::asval((PyObject*)first, pfirst);
	  if (!SWIG_IsOK(res1)) return res1;
	  U *psecond = 0;
	  int res2 = swig::asval((PyObject*)second, psecond);
	  if (!SWIG_IsOK(res2)) return res2;
	  return res1 > res2 ? res1 : res2;
	}
      }

      static int asptr(PyObject *obj, std::pair<T,U> **val) {
	int res = SWIG_ERROR;
	if (PyTuple_Check(obj)) {
	  if (PyTuple_GET_SIZE(obj) == 2) {
	    res = get_pair(PyTuple_GET_ITEM(obj,0),PyTuple_GET_ITEM(obj,1), val);
	  }
	} else if (PySequence_Check(obj)) {
	  if (PySequence_Size(obj) == 2) {
	    swig::SwigVar_PyObject first = PySequence_GetItem(obj,0);
	    swig::SwigVar_PyObject second = PySequence_GetItem(obj,1);
	    res = get_pair(first, second, val);
	  }
	} else {
	  value_type *p = 0;
	  swig_type_info *descriptor = swig::type_info<value_type>();
	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
	  if (SWIG_IsOK(res) && val)  *val = p;
	}
	return res;
      }
    };


    template <class T, class U >
    struct traits_from<std::pair<T,U> >   {
      static PyObject *from(const std::pair<T,U>& val) {
	PyObject* obj = PyTuple_New(2);
	PyTuple_SetItem(obj,0,swig::from(val.first));
	PyTuple_SetItem(obj,1,swig::from(val.second));
	return obj;
      }
    };
  }





































      namespace swig {
	template <>  struct traits<std::pair< gum::Instantiation, double > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "gum::Instantiation" "," "double" " >";
	  }
	};
      }
    

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


namespace gum {
  namespace multithreading {
    unsigned int getNumberOfThreads() {
      return gum::getNumberOfThreads();
    }

    unsigned int getMaxNumberOfThreads() {
      return gum::getMaxNumberOfThreads();
    }

    unsigned int getNumberOfLogicalProcessors() {
      return gum::getNumberOfLogicalProcessors();
    }
  }
}


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


#include "extensions/BNGenerator.h"


#include "extensions/InformationTheory.h"


#include "extensions/PRMexplorer.h"


#include <agrum/bn.h>

SWIGINTERN PyObject *gum_EssentialGraph_nodes(gum::EssentialGraph const *self){
    return PyAgrumHelper::PySetFromNodeSet(self->nodes());
  }
SWIGINTERN PyObject *gum_EssentialGraph_arcs(gum::EssentialGraph const *self){ // add for the sub-classes (including MixedGraph and PDAG)
    return PyAgrumHelper::PySetFromArcSet(self->arcs());
  }
SWIGINTERN PyObject *gum_EssentialGraph_parents(gum::EssentialGraph const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->parents(id));
  }
SWIGINTERN PyObject *gum_EssentialGraph_children(gum::EssentialGraph const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->children(id));
  }
SWIGINTERN PyObject *gum_EssentialGraph_edges(gum::EssentialGraph const *self){ // add for the sub-classes (including MixedGraph)
    return PyAgrumHelper::PySetFromEdgeSet(self->edges());
  }
SWIGINTERN PyObject *gum_EssentialGraph_neighbours(gum::EssentialGraph const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->neighbours(id));
  }
SWIGINTERN PyObject *gum_MarkovBlanket_nodes(gum::MarkovBlanket const *self){
    return PyAgrumHelper::PySetFromNodeSet(self->nodes());
  }
SWIGINTERN PyObject *gum_MarkovBlanket_arcs(gum::MarkovBlanket const *self){ // add for the sub-classes (including MixedGraph and PDAG)
    return PyAgrumHelper::PySetFromArcSet(self->arcs());
  }
SWIGINTERN PyObject *gum_MarkovBlanket_parents(gum::MarkovBlanket const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->parents(id));
  }
SWIGINTERN PyObject *gum_MarkovBlanket_children(gum::MarkovBlanket const *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->children(id));
  }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__ids(gum::IBayesNet< double > *self,std::vector< std::string,std::allocator< std::string > > const &names){
    return PyAgrumHelper::PyListFromNodeVect(self->ids(names));
  }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__nodeset(gum::IBayesNet< double > *self,std::vector< std::string,std::allocator< std::string > > const &names){
    return PyAgrumHelper::PySetFromNodeVect(self->ids(names));
  }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__minimalCondSet__SWIG_0(gum::IBayesNet< double > const *self,gum::NodeId target,PyObject *list){
    gum::NodeSet soids;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soids,list,self->variableNodeMap());
    return PyAgrumHelper::PySetFromNodeSet(self->minimalCondSet(target, soids));
  }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__minimalCondSet__SWIG_1(gum::IBayesNet< double > const *self,PyObject *targets,PyObject *list){
    gum::NodeSet sotargets;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sotargets,targets,self->variableNodeMap());

    gum::NodeSet soids;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soids,list,self->variableNodeMap());
    return PyAgrumHelper::PySetFromNodeSet(self->minimalCondSet(sotargets, soids));
  }
SWIGINTERN bool gum_IBayesNet_Sl_double_Sg__isIndependent__SWIG_0(gum::IBayesNet< double > *self,PyObject *X,PyObject *Y,PyObject *Z){
    gum::NodeSet nx,ny,nz;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nx,X,self->variableNodeMap());
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(ny,Y,self->variableNodeMap());
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nz,Z,self->variableNodeMap());
    return self->isIndependent(nx,ny,nz);
  }
SWIGINTERN bool gum_IBayesNet_Sl_double_Sg__isIndependent__SWIG_1(gum::IBayesNet< double > *self,PyObject *X,PyObject *Y){
    gum::NodeSet nx,ny,nz;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nx,X,self->variableNodeMap());
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(ny,Y,self->variableNodeMap());
    return self->isIndependent(nx,ny,nz);
  }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__names(gum::IBayesNet< double > const *self){
     PyObject* q=PySet_New(0);

     PyObject* pyval;
     for ( auto node : self->nodes()) {
       pyval=PyString_FromString(self->variable(node).name().c_str());
       PySet_Add(q,pyval);
       Py_DecRef(pyval);
     }
     return q;
  }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__nodes(gum::IBayesNet< double > const *self){
    return PyAgrumHelper::PySetFromNodeSet(self->nodes());
  }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__arcs(gum::IBayesNet< double > const *self){
     return PyAgrumHelper::PySetFromArcSet(self->arcs());
   }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__parents(gum::IBayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->parents(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__children(gum::IBayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->children(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__family(gum::IBayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->family(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__descendants(gum::IBayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->descendants(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__ancestors(gum::IBayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->ancestors(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN gum::UndiGraph gum_IBayesNet_Sl_double_Sg__moralizedAncestralGraph(gum::IBayesNet< double > *self,PyObject *nodes){
     gum::NodeSet sonodes;
     PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sonodes,nodes,self->variableNodeMap());
     return self->moralizedAncestralGraph(sonodes);
   }
SWIGINTERN std::string gum_IBayesNet_Sl_double_Sg____repr__(gum::IBayesNet< double > const *self){
   std::stringstream s;
   s<<"(pyagrum.IBayesNet@"<<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_BayesNet_Sl_double_Sg__ids(gum::BayesNet< double > *self,std::vector< std::string,std::allocator< std::string > > const &names){
    return PyAgrumHelper::PyListFromNodeVect(self->ids(names));
  }
SWIGINTERN PyObject *gum_BayesNet_Sl_double_Sg__nodeset(gum::BayesNet< double > *self,std::vector< std::string,std::allocator< std::string > > const &names){
    return PyAgrumHelper::PySetFromNodeVect(self->ids(names));
  }
SWIGINTERN PyObject *gum_BayesNet_Sl_double_Sg__minimalCondSet__SWIG_0(gum::BayesNet< double > const *self,gum::NodeId target,PyObject *list){
    gum::NodeSet soids;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soids,list,self->variableNodeMap());
    return PyAgrumHelper::PySetFromNodeSet(self->minimalCondSet(target, soids));
  }
SWIGINTERN PyObject *gum_BayesNet_Sl_double_Sg__minimalCondSet__SWIG_1(gum::BayesNet< double > const *self,PyObject *targets,PyObject *list){
    gum::NodeSet sotargets;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sotargets,targets,self->variableNodeMap());

    gum::NodeSet soids;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soids,list,self->variableNodeMap());
    return PyAgrumHelper::PySetFromNodeSet(self->minimalCondSet(sotargets, soids));
  }
SWIGINTERN bool gum_BayesNet_Sl_double_Sg__isIndependent__SWIG_0(gum::BayesNet< double > *self,PyObject *X,PyObject *Y,PyObject *Z){
    gum::NodeSet nx,ny,nz;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nx,X,self->variableNodeMap());
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(ny,Y,self->variableNodeMap());
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nz,Z,self->variableNodeMap());
    return self->isIndependent(nx,ny,nz);
  }
SWIGINTERN bool gum_BayesNet_Sl_double_Sg__isIndependent__SWIG_1(gum::BayesNet< double > *self,PyObject *X,PyObject *Y){
    gum::NodeSet nx,ny,nz;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nx,X,self->variableNodeMap());
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(ny,Y,self->variableNodeMap());
    return self->isIndependent(nx,ny,nz);
  }
SWIGINTERN PyObject *gum_BayesNet_Sl_double_Sg__names(gum::BayesNet< double > const *self){
     PyObject* q=PySet_New(0);

     PyObject* pyval;
     for ( auto node : self->nodes()) {
       pyval=PyString_FromString(self->variable(node).name().c_str());
       PySet_Add(q,pyval);
       Py_DecRef(pyval);
     }
     return q;
  }
SWIGINTERN PyObject *gum_BayesNet_Sl_double_Sg__nodes(gum::BayesNet< double > const *self){
    return PyAgrumHelper::PySetFromNodeSet(self->nodes());
  }
SWIGINTERN PyObject *gum_BayesNet_Sl_double_Sg__arcs(gum::BayesNet< double > const *self){
     return PyAgrumHelper::PySetFromArcSet(self->arcs());
   }
SWIGINTERN PyObject *gum_BayesNet_Sl_double_Sg__parents(gum::BayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->parents(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_BayesNet_Sl_double_Sg__children(gum::BayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->children(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_BayesNet_Sl_double_Sg__family(gum::BayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->family(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_BayesNet_Sl_double_Sg__descendants(gum::BayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->descendants(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_BayesNet_Sl_double_Sg__ancestors(gum::BayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->ancestors(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN gum::UndiGraph gum_BayesNet_Sl_double_Sg__moralizedAncestralGraph(gum::BayesNet< double > *self,PyObject *nodes){
     gum::NodeSet sonodes;
     PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sonodes,nodes,self->variableNodeMap());
     return self->moralizedAncestralGraph(sonodes);
   }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg__loadBIF__SWIG_0(gum::BayesNet< double > *self,std::string name,PyObject *l=nullptr){
      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++) {
              (reader.scanner()).onLoad.attach(&(py_listener[i]), &PythonLoadListener::whenLoading);
          }

          auto nbErr=reader.proceed();
          reader.showElegantErrorsAndWarnings(stream);
          if (nbErr>0) {
              reader.showErrorCounts(stream);
                   {                                       std::ostringstream err_stream;        err_stream << stream.str();                    throw(gum::FatalError(err_stream.str()));      }
          } else {
              return stream.str();
          }
      } catch (gum::IOError& e) {
        throw(e);
      }
      return "";
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__saveBIF__SWIG_0(gum::BayesNet< double > *self,std::string name,bool allowModificationWhenSaving=false){
      gum::BIFWriter<double> writer;
      writer.setAllowModification(allowModificationWhenSaving);
      writer.write( name, *self );
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg__loadDSL__SWIG_0(gum::BayesNet< double > *self,std::string name,PyObject *l=nullptr){
      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++) {
              (reader.scanner()).onLoad.attach(&(py_listener[i]), &PythonLoadListener::whenLoading);
          }

          auto nbErr=reader.proceed();
          reader.showElegantErrorsAndWarnings(stream);
          if (nbErr>0) {
              reader.showErrorCounts(stream);
                   {                                       std::ostringstream err_stream;        err_stream << stream.str();                    throw(gum::FatalError(err_stream.str()));      }
          } else {
              return stream.str();
          }
      } catch (gum::IOError& e) {
        throw(e);
      }
      return "plop";
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg__loadXDSL__SWIG_0(gum::BayesNet< double > *self,std::string name,PyObject *l=nullptr){
      try {
          gum::XDSLBNReader<double> reader(self,name);

          int isOK=reader.proceed();// for BIFXML, proceed() returns 0 or 1
          if (isOK==1) {
                   {                                       std::ostringstream err_stream;        err_stream << "Errors found in XML file";                    throw(gum::FatalError(err_stream.str()));      }
          } else {
              return "";
          }
      } catch (gum::IOError& e) {
        throw(e);
      }
      return "";
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__saveDSL__SWIG_0(gum::BayesNet< double > *self,std::string name,bool allowModificationWhenSaving=false){
    gum::DSLWriter<double> writer;
    writer.setAllowModification(allowModificationWhenSaving);
    writer.write( name, *self );
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__saveXDSL__SWIG_0(gum::BayesNet< double > *self,std::string name,bool allowModificationWhenSaving=false){
    gum::XDSLBNWriter<double> writer;
    writer.setAllowModification(allowModificationWhenSaving);
    writer.write( name, *self );
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg__loadNET__SWIG_0(gum::BayesNet< double > *self,std::string name,PyObject *l=nullptr){
      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++) {
              (reader.scanner()).onLoad.attach(&(py_listener[i]), &PythonLoadListener::whenLoading);
          }

          auto nbErr=reader.proceed();
          reader.showElegantErrorsAndWarnings(stream);
          if (nbErr>0) {
              reader.showErrorCounts(stream);
                   {                                       std::ostringstream err_stream;        err_stream << stream.str();                    throw(gum::FatalError(err_stream.str()));      }
          } else {
              return stream.str();
          }
      } catch (gum::IOError& e) {
        throw(e);
      }
      return "";
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__saveNET__SWIG_0(gum::BayesNet< double > *self,std::string name,bool allowModificationWhenSaving=false){
    gum::NetWriter<double> writer;
    writer.setAllowModification(allowModificationWhenSaving);
    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=nullptr){
      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);
                   {                                       std::ostringstream err_stream;        err_stream << stream.str();                    throw(gum::FatalError(err_stream.str()));      }
          } else {
              return stream.str();
          }
      } catch (gum::IOError& e) {
        throw(e);
      }
      return "";
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__saveO3PRM__SWIG_0(gum::BayesNet< double > *self,std::string name,bool allowModificationWhenSaving=false){
    gum::O3prmBNWriter<double> writer;
    writer.setAllowModification(allowModificationWhenSaving);
    writer.write( name, *self );
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg__loadBIFXML__SWIG_0(gum::BayesNet< double > *self,std::string name,PyObject *l=nullptr){
      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) {
                   {                                       std::ostringstream err_stream;        err_stream << "Errors found in XML file";                    throw(gum::FatalError(err_stream.str()));      }
          } else {
              return "";
          }
      } catch (gum::IOError& e) {
        throw(e);
      }
      return "";
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__saveBIFXML__SWIG_0(gum::BayesNet< double > *self,std::string name,bool allowModificationWhenSaving=false){
    gum::BIFXMLBNWriter<double> writer;
    writer.setAllowModification(allowModificationWhenSaving);
    writer.write( name, *self );
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg__loadUAI__SWIG_0(gum::BayesNet< double > *self,std::string name,PyObject *l=nullptr){
      std::stringstream stream;
      std::vector<PythonLoadListener> py_listener;

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

          auto nbErr=reader.proceed();
          reader.showElegantErrorsAndWarnings(stream);
          if (nbErr>0) {
              reader.showErrorCounts(stream);
                   {                                       std::ostringstream err_stream;        err_stream << stream.str();                    throw(gum::FatalError(err_stream.str()));      }
          } else {
              return stream.str();
          }
      } catch (gum::IOError& e) {
        throw(e);
      }
      return "";
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__saveUAI__SWIG_0(gum::BayesNet< double > *self,std::string name,bool allowModificationWhenSaving=false){
    gum::UAIBNWriter<double> writer;
    writer.setAllowModification(allowModificationWhenSaving);
    writer.write( name, *self );
  }
SWIGINTERN gum::BayesNet< double > gum_BayesNet_Sl_double_Sg__contextualize__SWIG_1(gum::BayesNet< double > *self,PyObject *observations,PyObject *interventions){
    if (PyDict_Check(observations) && PyDict_Check(interventions)) {
      gum::Instantiation instObservations;
      gum::Instantiation instInterventions;
      PyAgrumHelper::fillInstantiationFromPyObjectAndBN(self, instObservations, observations);
      PyAgrumHelper::fillInstantiationFromPyObjectAndBN(self, instInterventions, interventions);
      return self->contextualize(instObservations,instInterventions);
    } else {
           {                                       std::ostringstream err_stream;        err_stream << "arg is neither a dict or an pyagrum.Instantiation.";                    throw(gum::InvalidArgument(err_stream.str()));      };
    }
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg____repr__(gum::BayesNet< double > const *self){
   std::stringstream s;
   s<<"(pyagrum.BayesNet@"<<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 PyObject *gum_BayesNetFragment_Sl_double_Sg__ids(gum::BayesNetFragment< double > *self,std::vector< std::string,std::allocator< std::string > > const &names){
    return PyAgrumHelper::PyListFromNodeVect(self->ids(names));
  }
SWIGINTERN PyObject *gum_BayesNetFragment_Sl_double_Sg__nodeset(gum::BayesNetFragment< double > *self,std::vector< std::string,std::allocator< std::string > > const &names){
    return PyAgrumHelper::PySetFromNodeVect(self->ids(names));
  }
SWIGINTERN PyObject *gum_BayesNetFragment_Sl_double_Sg__minimalCondSet__SWIG_0(gum::BayesNetFragment< double > const *self,gum::NodeId target,PyObject *list){
    gum::NodeSet soids;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soids,list,self->variableNodeMap());
    return PyAgrumHelper::PySetFromNodeSet(self->minimalCondSet(target, soids));
  }
SWIGINTERN PyObject *gum_BayesNetFragment_Sl_double_Sg__minimalCondSet__SWIG_1(gum::BayesNetFragment< double > const *self,PyObject *targets,PyObject *list){
    gum::NodeSet sotargets;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sotargets,targets,self->variableNodeMap());

    gum::NodeSet soids;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soids,list,self->variableNodeMap());
    return PyAgrumHelper::PySetFromNodeSet(self->minimalCondSet(sotargets, soids));
  }
SWIGINTERN bool gum_BayesNetFragment_Sl_double_Sg__isIndependent__SWIG_0(gum::BayesNetFragment< double > *self,PyObject *X,PyObject *Y,PyObject *Z){
    gum::NodeSet nx,ny,nz;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nx,X,self->variableNodeMap());
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(ny,Y,self->variableNodeMap());
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nz,Z,self->variableNodeMap());
    return self->isIndependent(nx,ny,nz);
  }
SWIGINTERN bool gum_BayesNetFragment_Sl_double_Sg__isIndependent__SWIG_1(gum::BayesNetFragment< double > *self,PyObject *X,PyObject *Y){
    gum::NodeSet nx,ny,nz;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nx,X,self->variableNodeMap());
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(ny,Y,self->variableNodeMap());
    return self->isIndependent(nx,ny,nz);
  }
SWIGINTERN PyObject *gum_BayesNetFragment_Sl_double_Sg__names(gum::BayesNetFragment< double > const *self){
     PyObject* q=PySet_New(0);

     PyObject* pyval;
     for ( auto node : self->nodes()) {
       pyval=PyString_FromString(self->variable(node).name().c_str());
       PySet_Add(q,pyval);
       Py_DecRef(pyval);
     }
     return q;
  }
SWIGINTERN PyObject *gum_BayesNetFragment_Sl_double_Sg__nodes(gum::BayesNetFragment< double > const *self){
    return PyAgrumHelper::PySetFromNodeSet(self->nodes());
  }
SWIGINTERN PyObject *gum_BayesNetFragment_Sl_double_Sg__arcs(gum::BayesNetFragment< double > const *self){
     return PyAgrumHelper::PySetFromArcSet(self->arcs());
   }
SWIGINTERN PyObject *gum_BayesNetFragment_Sl_double_Sg__parents(gum::BayesNetFragment< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->parents(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_BayesNetFragment_Sl_double_Sg__children(gum::BayesNetFragment< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->children(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_BayesNetFragment_Sl_double_Sg__family(gum::BayesNetFragment< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->family(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_BayesNetFragment_Sl_double_Sg__descendants(gum::BayesNetFragment< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->descendants(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_BayesNetFragment_Sl_double_Sg__ancestors(gum::BayesNetFragment< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->ancestors(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN gum::UndiGraph gum_BayesNetFragment_Sl_double_Sg__moralizedAncestralGraph(gum::BayesNetFragment< double > *self,PyObject *nodes){
     gum::NodeSet sonodes;
     PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sonodes,nodes,self->variableNodeMap());
     return self->moralizedAncestralGraph(sonodes);
   }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__makeInference(gum::LazyPropagation< double > *self){
    self->gum::MarginalTargetedInference<double>::makeInference();
  }
SWIGINTERN gum::Tensor< double > const gum_LazyPropagation_Sl_double_Sg__posterior__SWIG_0(gum::LazyPropagation< double > *self,gum::NodeId const var){
    return self->gum::MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Tensor< double > const gum_LazyPropagation_Sl_double_Sg__posterior__SWIG_1(gum::LazyPropagation< double > *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_0(gum::LazyPropagation< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_6(gum::LazyPropagation< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::addEvidence(p);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_0(gum::LazyPropagation< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_4(gum::LazyPropagation< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::chgEvidence(p);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_5(gum::LazyPropagation< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::MarginalTargetedInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_6(gum::LazyPropagation< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__eraseAllEvidence(gum::LazyPropagation< double > *self){
    self->gum::MarginalTargetedInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__eraseEvidence__SWIG_0(gum::LazyPropagation< double > *self,gum::NodeId const id){
    self->gum::MarginalTargetedInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__eraseEvidence__SWIG_1(gum::LazyPropagation< double > *self,std::string const &nodeName){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_LazyPropagation_Sl_double_Sg__hasHardEvidence(gum::LazyPropagation< double > const *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_LazyPropagation_Sl_double_Sg__nbrEvidence(gum::LazyPropagation< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_LazyPropagation_Sl_double_Sg__nbrHardEvidence(gum::LazyPropagation< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_LazyPropagation_Sl_double_Sg__nbrSoftEvidence(gum::LazyPropagation< double > const *self){
    return self->gum::MarginalTargetedInference<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::Tensor< double > gum_LazyPropagation_Sl_double_Sg__evidenceImpact__SWIG_0(gum::LazyPropagation< double > *self,gum::NodeId target,gum::NodeSet const &evs){
    return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Tensor< 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 gum::IBayesNet< double > const &gum_LazyPropagation_Sl_double_Sg__BN(gum::LazyPropagation< double > const *self){ return self->gum::MarginalTargetedInference<double>::BN(); }
SWIGINTERN gum::Tensor< double > const gum_LazyPropagation_Sl_double_Sg__posterior__SWIG_2(gum::LazyPropagation< double > *self,std::string const nodeName){
    return self->JointTargetedInference<double>::posterior(nodeName);
  }
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 gum::Tensor< double > gum_LazyPropagation_Sl_double_Sg__evidenceJointImpact__SWIG_0(gum::LazyPropagation< double > *self,gum::NodeSet const &targets,gum::NodeSet const &evs){
    return self->gum::JointTargetedInference<double>::evidenceJointImpact(targets,evs);
  }
SWIGINTERN gum::Tensor< 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_LazyPropagation_Sl_double_Sg__setNumberOfThreads(gum::LazyPropagation< double > *self,int nb){
    self->setNumberOfThreads(nb);
  }
SWIGINTERN int gum_LazyPropagation_Sl_double_Sg__getNumberOfThreads(gum::LazyPropagation< double > *self){
    return self->getNumberOfThreads();
  }
SWIGINTERN bool gum_LazyPropagation_Sl_double_Sg__isGumNumberOfThreadsOverriden(gum::LazyPropagation< double > *self){
    return self->isGumNumberOfThreadsOverriden();
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__setMaxMemory(gum::LazyPropagation< double > *self,int gigabytes){
    self->setMaxMemory(gigabytes);
  }
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::Tensor< double > gum_LazyPropagation_Sl_double_Sg__evidenceImpact__SWIG_2(gum::LazyPropagation< double > *self,PyObject *target,PyObject *evs){
      gum::NodeId itarget=PyAgrumHelper::nodeIdFromNameOrIndex(target,self->BN().variableNodeMap());
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceImpact(itarget,soe);
    }
SWIGINTERN double gum_LazyPropagation_Sl_double_Sg__jointMutualInformation(gum::LazyPropagation< double > *self,PyObject *targets){
      gum::NodeSet sot;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sot,targets,self->BN().variableNodeMap());
      return self->jointMutualInformation(sot);
    }
SWIGINTERN gum::Tensor< double > gum_LazyPropagation_Sl_double_Sg__evidenceJointImpact__SWIG_2(gum::LazyPropagation< double > *self,PyObject *targets,PyObject *evs){
      gum::NodeSet sot;
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sot,targets,self->BN().variableNodeMap());
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceJointImpact(sot,soe);
    }
SWIGINTERN gum::Tensor< double > gum_LazyPropagation_Sl_double_Sg__jointPosterior(gum::LazyPropagation< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->BN().variableNodeMap());
      return self->jointPosterior(nodeset);
    }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__addJointTarget(gum::LazyPropagation< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->BN().variableNodeMap());

      self->gum::JointTargetedInference<double>::addJointTarget(nodeset);
    }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__eraseJointTarget(gum::LazyPropagation< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->BN().variableNodeMap());
      self->gum::JointTargetedInference<double>::eraseJointTarget(nodeset);
    }
SWIGINTERN bool gum_LazyPropagation_Sl_double_Sg__isJointTarget(gum::LazyPropagation< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->BN().variableNodeMap());
      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 );

      PyObject* pyval;
      for ( auto ns : self->JointTargetedInference<double>::jointTargets()) {
        pyval=PyAgrumHelper::PySetFromNodeSet(ns);
        PyList_Append( q,pyval);
        Py_DecRef(pyval);
      }
      return q;
    }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__makeInference(gum::ShaferShenoyInference< double > *self){
    self->gum::MarginalTargetedInference<double>::makeInference();
  }
SWIGINTERN gum::Tensor< double > const gum_ShaferShenoyInference_Sl_double_Sg__posterior__SWIG_0(gum::ShaferShenoyInference< double > *self,gum::NodeId const var){
    return self->gum::MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Tensor< double > const gum_ShaferShenoyInference_Sl_double_Sg__posterior__SWIG_1(gum::ShaferShenoyInference< double > *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_0(gum::ShaferShenoyInference< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_6(gum::ShaferShenoyInference< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::addEvidence(p);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_0(gum::ShaferShenoyInference< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_4(gum::ShaferShenoyInference< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::chgEvidence(p);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_5(gum::ShaferShenoyInference< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::MarginalTargetedInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_6(gum::ShaferShenoyInference< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__eraseAllEvidence(gum::ShaferShenoyInference< double > *self){
    self->gum::MarginalTargetedInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__eraseEvidence__SWIG_0(gum::ShaferShenoyInference< double > *self,gum::NodeId const id){
    self->gum::MarginalTargetedInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__eraseEvidence__SWIG_1(gum::ShaferShenoyInference< double > *self,std::string const &nodeName){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_ShaferShenoyInference_Sl_double_Sg__hasHardEvidence(gum::ShaferShenoyInference< double > const *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_ShaferShenoyInference_Sl_double_Sg__nbrEvidence(gum::ShaferShenoyInference< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_ShaferShenoyInference_Sl_double_Sg__nbrHardEvidence(gum::ShaferShenoyInference< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_ShaferShenoyInference_Sl_double_Sg__nbrSoftEvidence(gum::ShaferShenoyInference< double > const *self){
    return self->gum::MarginalTargetedInference<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::Tensor< double > gum_ShaferShenoyInference_Sl_double_Sg__evidenceImpact__SWIG_0(gum::ShaferShenoyInference< double > *self,gum::NodeId target,gum::NodeSet const &evs){
    return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Tensor< 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 gum::IBayesNet< double > const &gum_ShaferShenoyInference_Sl_double_Sg__BN(gum::ShaferShenoyInference< double > const *self){ return self->gum::MarginalTargetedInference<double>::BN(); }
SWIGINTERN gum::Tensor< double > const gum_ShaferShenoyInference_Sl_double_Sg__posterior__SWIG_2(gum::ShaferShenoyInference< double > *self,std::string const nodeName){
    return self->JointTargetedInference<double>::posterior(nodeName);
  }
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 gum::Tensor< double > gum_ShaferShenoyInference_Sl_double_Sg__evidenceJointImpact__SWIG_0(gum::ShaferShenoyInference< double > *self,gum::NodeSet const &targets,gum::NodeSet const &evs){
    return self->gum::JointTargetedInference<double>::evidenceJointImpact(targets,evs);
  }
SWIGINTERN gum::Tensor< 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_ShaferShenoyInference_Sl_double_Sg__setNumberOfThreads(gum::ShaferShenoyInference< double > *self,int nb){
    self->setNumberOfThreads(nb);
  }
SWIGINTERN int gum_ShaferShenoyInference_Sl_double_Sg__getNumberOfThreads(gum::ShaferShenoyInference< double > *self){
    return self->getNumberOfThreads();
  }
SWIGINTERN bool gum_ShaferShenoyInference_Sl_double_Sg__isGumNumberOfThreadsOverriden(gum::ShaferShenoyInference< double > *self){
    return self->isGumNumberOfThreadsOverriden();
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__setMaxMemory(gum::ShaferShenoyInference< double > *self,int gigabytes){
    self->setMaxMemory(gigabytes);
  }
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::Tensor< double > gum_ShaferShenoyInference_Sl_double_Sg__evidenceImpact__SWIG_2(gum::ShaferShenoyInference< double > *self,PyObject *target,PyObject *evs){
      gum::NodeId itarget=PyAgrumHelper::nodeIdFromNameOrIndex(target,self->BN().variableNodeMap());
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceImpact(itarget,soe);
    }
SWIGINTERN double gum_ShaferShenoyInference_Sl_double_Sg__jointMutualInformation(gum::ShaferShenoyInference< double > *self,PyObject *targets){
      gum::NodeSet sot;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sot,targets,self->BN().variableNodeMap());
      return self->jointMutualInformation(sot);
    }
SWIGINTERN gum::Tensor< double > gum_ShaferShenoyInference_Sl_double_Sg__evidenceJointImpact__SWIG_2(gum::ShaferShenoyInference< double > *self,PyObject *targets,PyObject *evs){
      gum::NodeSet sot;
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sot,targets,self->BN().variableNodeMap());
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceJointImpact(sot,soe);
    }
SWIGINTERN gum::Tensor< double > gum_ShaferShenoyInference_Sl_double_Sg__jointPosterior(gum::ShaferShenoyInference< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->BN().variableNodeMap());
      return self->jointPosterior(nodeset);
    }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__addJointTarget(gum::ShaferShenoyInference< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->BN().variableNodeMap());

      self->gum::JointTargetedInference<double>::addJointTarget(nodeset);
    }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__eraseJointTarget(gum::ShaferShenoyInference< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->BN().variableNodeMap());
      self->gum::JointTargetedInference<double>::eraseJointTarget(nodeset);
    }
SWIGINTERN bool gum_ShaferShenoyInference_Sl_double_Sg__isJointTarget(gum::ShaferShenoyInference< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->BN().variableNodeMap());
      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 );

      PyObject* pyval;
      for ( auto ns : self->JointTargetedInference<double>::jointTargets()) {
        pyval=PyAgrumHelper::PySetFromNodeSet(ns);
        PyList_Append( q,pyval);
        Py_DecRef(pyval);
      }
      return q;
    }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__makeInference(gum::VariableElimination< double > *self){
    self->gum::MarginalTargetedInference<double>::makeInference();
  }
SWIGINTERN gum::Tensor< double > const gum_VariableElimination_Sl_double_Sg__posterior__SWIG_0(gum::VariableElimination< double > *self,gum::NodeId const var){
    return self->gum::MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Tensor< double > const gum_VariableElimination_Sl_double_Sg__posterior__SWIG_1(gum::VariableElimination< double > *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_0(gum::VariableElimination< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_6(gum::VariableElimination< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::addEvidence(p);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_0(gum::VariableElimination< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_4(gum::VariableElimination< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::chgEvidence(p);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_5(gum::VariableElimination< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::MarginalTargetedInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_6(gum::VariableElimination< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__eraseAllEvidence(gum::VariableElimination< double > *self){
    self->gum::MarginalTargetedInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__eraseEvidence__SWIG_0(gum::VariableElimination< double > *self,gum::NodeId const id){
    self->gum::MarginalTargetedInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__eraseEvidence__SWIG_1(gum::VariableElimination< double > *self,std::string const &nodeName){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_VariableElimination_Sl_double_Sg__hasHardEvidence(gum::VariableElimination< double > const *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_VariableElimination_Sl_double_Sg__nbrEvidence(gum::VariableElimination< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_VariableElimination_Sl_double_Sg__nbrHardEvidence(gum::VariableElimination< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_VariableElimination_Sl_double_Sg__nbrSoftEvidence(gum::VariableElimination< double > const *self){
    return self->gum::MarginalTargetedInference<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::Tensor< double > gum_VariableElimination_Sl_double_Sg__evidenceImpact__SWIG_0(gum::VariableElimination< double > *self,gum::NodeId target,gum::NodeSet const &evs){
    return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Tensor< 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 gum::IBayesNet< double > const &gum_VariableElimination_Sl_double_Sg__BN(gum::VariableElimination< double > const *self){ return self->gum::MarginalTargetedInference<double>::BN(); }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__setNumberOfThreads(gum::VariableElimination< double > *self,int nb){
    self->setNumberOfThreads(nb);
  }
SWIGINTERN int gum_VariableElimination_Sl_double_Sg__getNumberOfThreads(gum::VariableElimination< double > *self){
    return self->getNumberOfThreads();
  }
SWIGINTERN bool gum_VariableElimination_Sl_double_Sg__isGumNumberOfThreadsOverriden(gum::VariableElimination< double > *self){
    return self->isGumNumberOfThreadsOverriden();
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__setMaxMemory(gum::VariableElimination< double > *self,int gigabytes){
    self->setMaxMemory(gigabytes);
  }
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::Tensor< double > gum_VariableElimination_Sl_double_Sg__evidenceImpact__SWIG_2(gum::VariableElimination< double > *self,PyObject *target,PyObject *evs){
      gum::NodeId itarget=PyAgrumHelper::nodeIdFromNameOrIndex(target,self->BN().variableNodeMap());
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceImpact(itarget,soe);
    }
SWIGINTERN double gum_VariableElimination_Sl_double_Sg__jointMutualInformation(gum::VariableElimination< double > *self,PyObject *targets){
      gum::NodeSet sot;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sot,targets,self->BN().variableNodeMap());
      return self->jointMutualInformation(sot);
    }
SWIGINTERN gum::Tensor< 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().variableNodeMap());
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceJointImpact(sot,soe);
    }
SWIGINTERN gum::Tensor< double > gum_VariableElimination_Sl_double_Sg__jointPosterior(gum::VariableElimination< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->BN().variableNodeMap());
      return self->jointPosterior(nodeset);
    }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__addJointTarget(gum::VariableElimination< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->BN().variableNodeMap());

      self->gum::JointTargetedInference<double>::addJointTarget(nodeset);
    }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__eraseJointTarget(gum::VariableElimination< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->BN().variableNodeMap());
      self->gum::JointTargetedInference<double>::eraseJointTarget(nodeset);
    }
SWIGINTERN bool gum_VariableElimination_Sl_double_Sg__isJointTarget(gum::VariableElimination< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->BN().variableNodeMap());
      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 );

      PyObject* pyval;
      for ( auto ns : self->JointTargetedInference<double>::jointTargets()) {
        pyval=PyAgrumHelper::PySetFromNodeSet(ns);
        PyList_Append( q,pyval);
        Py_DecRef(pyval);
      }
      return q;
    }
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::MarginalTargetedInference<double>::makeInference();
  }
SWIGINTERN gum::Tensor< double > const gum_GibbsSampling_Sl_double_Sg__posterior__SWIG_0(gum::GibbsSampling< double > *self,gum::NodeId const var){
    return self->gum::MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Tensor< double > const gum_GibbsSampling_Sl_double_Sg__posterior__SWIG_1(gum::GibbsSampling< double > *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_0(gum::GibbsSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_6(gum::GibbsSampling< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::addEvidence(p);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_0(gum::GibbsSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_4(gum::GibbsSampling< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::chgEvidence(p);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_5(gum::GibbsSampling< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::MarginalTargetedInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_6(gum::GibbsSampling< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__eraseAllEvidence(gum::GibbsSampling< double > *self){
    self->gum::MarginalTargetedInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__eraseEvidence__SWIG_0(gum::GibbsSampling< double > *self,gum::NodeId const id){
    self->gum::MarginalTargetedInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__eraseEvidence__SWIG_1(gum::GibbsSampling< double > *self,std::string const &nodeName){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_GibbsSampling_Sl_double_Sg__hasHardEvidence(gum::GibbsSampling< double > const *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_GibbsSampling_Sl_double_Sg__nbrEvidence(gum::GibbsSampling< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_GibbsSampling_Sl_double_Sg__nbrHardEvidence(gum::GibbsSampling< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_GibbsSampling_Sl_double_Sg__nbrSoftEvidence(gum::GibbsSampling< double > const *self){
    return self->gum::MarginalTargetedInference<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::Tensor< double > gum_GibbsSampling_Sl_double_Sg__evidenceImpact__SWIG_0(gum::GibbsSampling< double > *self,gum::NodeId target,gum::NodeSet const &evs){
    return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Tensor< 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::IBayesNet< double > const &gum_GibbsSampling_Sl_double_Sg__BN(gum::GibbsSampling< double > const *self){ return self->gum::MarginalTargetedInference<double>::BN(); }
SWIGINTERN gum::Tensor< 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::Tensor< 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_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::Tensor< double > gum_GibbsSampling_Sl_double_Sg__evidenceImpact__SWIG_2(gum::GibbsSampling< double > *self,PyObject *target,PyObject *evs){
      gum::NodeId itarget=PyAgrumHelper::nodeIdFromNameOrIndex(target,self->BN().variableNodeMap());
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceImpact(itarget,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::MarginalTargetedInference<double>::makeInference();
  }
SWIGINTERN gum::Tensor< double > const gum_ImportanceSampling_Sl_double_Sg__posterior__SWIG_0(gum::ImportanceSampling< double > *self,gum::NodeId const var){
    return self->gum::MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Tensor< double > const gum_ImportanceSampling_Sl_double_Sg__posterior__SWIG_1(gum::ImportanceSampling< double > *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_0(gum::ImportanceSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_6(gum::ImportanceSampling< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::addEvidence(p);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_0(gum::ImportanceSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_4(gum::ImportanceSampling< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::chgEvidence(p);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_5(gum::ImportanceSampling< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::MarginalTargetedInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_6(gum::ImportanceSampling< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__eraseAllEvidence(gum::ImportanceSampling< double > *self){
    self->gum::MarginalTargetedInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__eraseEvidence__SWIG_0(gum::ImportanceSampling< double > *self,gum::NodeId const id){
    self->gum::MarginalTargetedInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__eraseEvidence__SWIG_1(gum::ImportanceSampling< double > *self,std::string const &nodeName){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_ImportanceSampling_Sl_double_Sg__hasHardEvidence(gum::ImportanceSampling< double > const *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_ImportanceSampling_Sl_double_Sg__nbrEvidence(gum::ImportanceSampling< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_ImportanceSampling_Sl_double_Sg__nbrHardEvidence(gum::ImportanceSampling< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_ImportanceSampling_Sl_double_Sg__nbrSoftEvidence(gum::ImportanceSampling< double > const *self){
    return self->gum::MarginalTargetedInference<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::Tensor< double > gum_ImportanceSampling_Sl_double_Sg__evidenceImpact__SWIG_0(gum::ImportanceSampling< double > *self,gum::NodeId target,gum::NodeSet const &evs){
    return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Tensor< 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::IBayesNet< double > const &gum_ImportanceSampling_Sl_double_Sg__BN(gum::ImportanceSampling< double > const *self){ return self->gum::MarginalTargetedInference<double>::BN(); }
SWIGINTERN gum::Tensor< 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::Tensor< 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_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::Tensor< double > gum_ImportanceSampling_Sl_double_Sg__evidenceImpact__SWIG_2(gum::ImportanceSampling< double > *self,PyObject *target,PyObject *evs){
      gum::NodeId itarget=PyAgrumHelper::nodeIdFromNameOrIndex(target,self->BN().variableNodeMap());
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceImpact(itarget,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::MarginalTargetedInference<double>::makeInference();
  }
SWIGINTERN gum::Tensor< double > const gum_WeightedSampling_Sl_double_Sg__posterior__SWIG_0(gum::WeightedSampling< double > *self,gum::NodeId const var){
    return self->gum::MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Tensor< double > const gum_WeightedSampling_Sl_double_Sg__posterior__SWIG_1(gum::WeightedSampling< double > *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_0(gum::WeightedSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_6(gum::WeightedSampling< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::addEvidence(p);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_0(gum::WeightedSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_4(gum::WeightedSampling< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::chgEvidence(p);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_5(gum::WeightedSampling< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::MarginalTargetedInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_6(gum::WeightedSampling< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__eraseAllEvidence(gum::WeightedSampling< double > *self){
    self->gum::MarginalTargetedInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__eraseEvidence__SWIG_0(gum::WeightedSampling< double > *self,gum::NodeId const id){
    self->gum::MarginalTargetedInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__eraseEvidence__SWIG_1(gum::WeightedSampling< double > *self,std::string const &nodeName){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_WeightedSampling_Sl_double_Sg__hasHardEvidence(gum::WeightedSampling< double > const *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_WeightedSampling_Sl_double_Sg__nbrEvidence(gum::WeightedSampling< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_WeightedSampling_Sl_double_Sg__nbrHardEvidence(gum::WeightedSampling< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_WeightedSampling_Sl_double_Sg__nbrSoftEvidence(gum::WeightedSampling< double > const *self){
    return self->gum::MarginalTargetedInference<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::Tensor< double > gum_WeightedSampling_Sl_double_Sg__evidenceImpact__SWIG_0(gum::WeightedSampling< double > *self,gum::NodeId target,gum::NodeSet const &evs){
    return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Tensor< 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::IBayesNet< double > const &gum_WeightedSampling_Sl_double_Sg__BN(gum::WeightedSampling< double > const *self){ return self->gum::MarginalTargetedInference<double>::BN(); }
SWIGINTERN gum::Tensor< 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::Tensor< 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_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::Tensor< double > gum_WeightedSampling_Sl_double_Sg__evidenceImpact__SWIG_2(gum::WeightedSampling< double > *self,PyObject *target,PyObject *evs){
      gum::NodeId itarget=PyAgrumHelper::nodeIdFromNameOrIndex(target,self->BN().variableNodeMap());
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceImpact(itarget,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::MarginalTargetedInference<double>::makeInference();
  }
SWIGINTERN gum::Tensor< double > const gum_MonteCarloSampling_Sl_double_Sg__posterior__SWIG_0(gum::MonteCarloSampling< double > *self,gum::NodeId const var){
    return self->gum::MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Tensor< double > const gum_MonteCarloSampling_Sl_double_Sg__posterior__SWIG_1(gum::MonteCarloSampling< double > *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_0(gum::MonteCarloSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_6(gum::MonteCarloSampling< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::addEvidence(p);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_0(gum::MonteCarloSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_4(gum::MonteCarloSampling< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::chgEvidence(p);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_5(gum::MonteCarloSampling< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::MarginalTargetedInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_6(gum::MonteCarloSampling< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__eraseAllEvidence(gum::MonteCarloSampling< double > *self){
    self->gum::MarginalTargetedInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__eraseEvidence__SWIG_0(gum::MonteCarloSampling< double > *self,gum::NodeId const id){
    self->gum::MarginalTargetedInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__eraseEvidence__SWIG_1(gum::MonteCarloSampling< double > *self,std::string const &nodeName){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_MonteCarloSampling_Sl_double_Sg__hasHardEvidence(gum::MonteCarloSampling< double > const *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_MonteCarloSampling_Sl_double_Sg__nbrEvidence(gum::MonteCarloSampling< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_MonteCarloSampling_Sl_double_Sg__nbrHardEvidence(gum::MonteCarloSampling< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_MonteCarloSampling_Sl_double_Sg__nbrSoftEvidence(gum::MonteCarloSampling< double > const *self){
    return self->gum::MarginalTargetedInference<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::Tensor< double > gum_MonteCarloSampling_Sl_double_Sg__evidenceImpact__SWIG_0(gum::MonteCarloSampling< double > *self,gum::NodeId target,gum::NodeSet const &evs){
    return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Tensor< 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::IBayesNet< double > const &gum_MonteCarloSampling_Sl_double_Sg__BN(gum::MonteCarloSampling< double > const *self){ return self->gum::MarginalTargetedInference<double>::BN(); }
SWIGINTERN gum::Tensor< 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::Tensor< 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_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::Tensor< double > gum_MonteCarloSampling_Sl_double_Sg__evidenceImpact__SWIG_2(gum::MonteCarloSampling< double > *self,PyObject *target,PyObject *evs){
      gum::NodeId itarget=PyAgrumHelper::nodeIdFromNameOrIndex(target,self->BN().variableNodeMap());
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceImpact(itarget,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::MarginalTargetedInference<double>::makeInference();
  }
SWIGINTERN gum::Tensor< 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->gum::MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Tensor< 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->gum::MarginalTargetedInference<double>::posterior(nodeName);
  }
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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addEvidence__SWIG_6(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::addEvidence(p);
  }
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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_4(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::chgEvidence(p);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_5(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::MarginalTargetedInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_6(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__eraseAllEvidence(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__nbrHardEvidence(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__nbrSoftEvidence(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){
    return self->gum::MarginalTargetedInference<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::Tensor< double > gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__evidenceImpact__SWIG_0(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId target,gum::NodeSet const &evs){
    return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Tensor< 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::IBayesNet< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__BN(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){ return self->gum::MarginalTargetedInference<double>::BN(); }
SWIGINTERN gum::Tensor< 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::Tensor< 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_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::Tensor< double > gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__evidenceImpact__SWIG_2(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,PyObject *target,PyObject *evs){
      gum::NodeId itarget=PyAgrumHelper::nodeIdFromNameOrIndex(target,self->BN().variableNodeMap());
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceImpact(itarget,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::MarginalTargetedInference<double>::makeInference();
  }
SWIGINTERN gum::Tensor< 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->gum::MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Tensor< 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->gum::MarginalTargetedInference<double>::posterior(nodeName);
  }
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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addEvidence__SWIG_6(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::addEvidence(p);
  }
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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_4(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::chgEvidence(p);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_5(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::MarginalTargetedInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_6(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__eraseAllEvidence(gum::LoopySamplingInference< double,gum::WeightedSampling > *self){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__nbrHardEvidence(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__nbrSoftEvidence(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){
    return self->gum::MarginalTargetedInference<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::Tensor< double > gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__evidenceImpact__SWIG_0(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId target,gum::NodeSet const &evs){
    return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Tensor< 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::IBayesNet< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__BN(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){ return self->gum::MarginalTargetedInference<double>::BN(); }
SWIGINTERN gum::Tensor< 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::Tensor< 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_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::Tensor< double > gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__evidenceImpact__SWIG_2(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,PyObject *target,PyObject *evs){
      gum::NodeId itarget=PyAgrumHelper::nodeIdFromNameOrIndex(target,self->BN().variableNodeMap());
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceImpact(itarget,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::MarginalTargetedInference<double>::makeInference();
  }
SWIGINTERN gum::Tensor< 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->gum::MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Tensor< 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->gum::MarginalTargetedInference<double>::posterior(nodeName);
  }
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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addEvidence__SWIG_6(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::addEvidence(p);
  }
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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_4(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::chgEvidence(p);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_5(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::MarginalTargetedInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_6(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__eraseAllEvidence(gum::LoopySamplingInference< double,gum::GibbsSampling > *self){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__nbrHardEvidence(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__nbrSoftEvidence(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){
    return self->gum::MarginalTargetedInference<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::Tensor< double > gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__evidenceImpact__SWIG_0(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId target,gum::NodeSet const &evs){
    return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Tensor< 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::IBayesNet< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__BN(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){ return self->gum::MarginalTargetedInference<double>::BN(); }
SWIGINTERN gum::Tensor< 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::Tensor< 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_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::Tensor< double > gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__evidenceImpact__SWIG_2(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,PyObject *target,PyObject *evs){
      gum::NodeId itarget=PyAgrumHelper::nodeIdFromNameOrIndex(target,self->BN().variableNodeMap());
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceImpact(itarget,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::MarginalTargetedInference<double>::makeInference();
  }
SWIGINTERN gum::Tensor< 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->gum::MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Tensor< 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->gum::MarginalTargetedInference<double>::posterior(nodeName);
  }
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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addEvidence__SWIG_6(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::addEvidence(p);
  }
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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_4(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::chgEvidence(p);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_5(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::MarginalTargetedInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_6(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__eraseAllEvidence(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__nbrHardEvidence(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__nbrSoftEvidence(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){
    return self->gum::MarginalTargetedInference<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::Tensor< double > gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__evidenceImpact__SWIG_0(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId target,gum::NodeSet const &evs){
    return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Tensor< 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::IBayesNet< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__BN(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){ return self->gum::MarginalTargetedInference<double>::BN(); }
SWIGINTERN gum::Tensor< 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::Tensor< 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_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::Tensor< double > gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__evidenceImpact__SWIG_2(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,PyObject *target,PyObject *evs){
      gum::NodeId itarget=PyAgrumHelper::nodeIdFromNameOrIndex(target,self->BN().variableNodeMap());
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceImpact(itarget,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::MarginalTargetedInference<double>::makeInference();
  }
SWIGINTERN gum::Tensor< double > const gum_LoopyBeliefPropagation_Sl_double_Sg__posterior__SWIG_0(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const var){
    return self->gum::MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Tensor< double > const gum_LoopyBeliefPropagation_Sl_double_Sg__posterior__SWIG_1(gum::LoopyBeliefPropagation< double > *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_0(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_6(gum::LoopyBeliefPropagation< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::addEvidence(p);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_0(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_4(gum::LoopyBeliefPropagation< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedInference<double>::chgEvidence(p);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_5(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::MarginalTargetedInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_6(gum::LoopyBeliefPropagation< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__eraseAllEvidence(gum::LoopyBeliefPropagation< double > *self){
    self->gum::MarginalTargetedInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__eraseEvidence__SWIG_0(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const id){
    self->gum::MarginalTargetedInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__eraseEvidence__SWIG_1(gum::LoopyBeliefPropagation< double > *self,std::string const &nodeName){
    self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_LoopyBeliefPropagation_Sl_double_Sg__hasHardEvidence(gum::LoopyBeliefPropagation< double > const *self,std::string const &nodeName){
    return self->gum::MarginalTargetedInference<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::MarginalTargetedInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_LoopyBeliefPropagation_Sl_double_Sg__nbrEvidence(gum::LoopyBeliefPropagation< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_LoopyBeliefPropagation_Sl_double_Sg__nbrHardEvidence(gum::LoopyBeliefPropagation< double > const *self){
    return self->gum::MarginalTargetedInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_LoopyBeliefPropagation_Sl_double_Sg__nbrSoftEvidence(gum::LoopyBeliefPropagation< double > const *self){
    return self->gum::MarginalTargetedInference<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::Tensor< double > gum_LoopyBeliefPropagation_Sl_double_Sg__evidenceImpact__SWIG_0(gum::LoopyBeliefPropagation< double > *self,gum::NodeId target,gum::NodeSet const &evs){
    return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Tensor< 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 gum::IBayesNet< double > const &gum_LoopyBeliefPropagation_Sl_double_Sg__BN(gum::LoopyBeliefPropagation< double > const *self){ return self->gum::MarginalTargetedInference<double>::BN(); }
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::Tensor< double > gum_LoopyBeliefPropagation_Sl_double_Sg__evidenceImpact__SWIG_2(gum::LoopyBeliefPropagation< double > *self,PyObject *target,PyObject *evs){
      gum::NodeId itarget=PyAgrumHelper::nodeIdFromNameOrIndex(target,self->BN().variableNodeMap());
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN().variableNodeMap());
      return self->evidenceImpact(itarget,soe);
    }
SWIGINTERN PyObject *gum_ExactBNdistance_Sl_double_Sg__compute(gum::ExactBNdistance< double > *self){
  PyObject* q=PyDict_New();

  PyObject* pyval;

  pyval=PyFloat_FromDouble(self->klPQ());
  PyDict_SetItemString(q,"klPQ",pyval);
  Py_DecRef(pyval);

  pyval=PyInt_FromLong(self->errorPQ());
  PyDict_SetItemString(q,"errorPQ",PyInt_FromLong(self->errorPQ()));
  Py_DecRef(pyval);

  pyval=PyFloat_FromDouble(self->klQP());
  PyDict_SetItemString(q,"klQP",PyFloat_FromDouble(self->klQP()));
  Py_DecRef(pyval);

  pyval=PyInt_FromLong(self->errorQP());
  PyDict_SetItemString(q,"errorQP",PyInt_FromLong(self->errorQP()));
  Py_DecRef(pyval);

  pyval=PyFloat_FromDouble(self->hellinger());
  PyDict_SetItemString(q,"hellinger",PyFloat_FromDouble(self->hellinger()));
  Py_DecRef(pyval);

  pyval=PyFloat_FromDouble(self->bhattacharya());
  PyDict_SetItemString(q,"bhattacharya",PyFloat_FromDouble(self->bhattacharya()));
  Py_DecRef(pyval);

  pyval=PyFloat_FromDouble(self->jsd());
  PyDict_SetItemString(q,"jensen-shannon",PyFloat_FromDouble(self->jsd()));
  Py_DecRef(pyval);

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

  PyObject* pyval;

  pyval=PyFloat_FromDouble(self->klPQ());
  PyDict_SetItemString(q,"klPQ",pyval);
  Py_DecRef(pyval);

  pyval=PyInt_FromLong(self->errorPQ());
  PyDict_SetItemString(q,"errorPQ",PyInt_FromLong(self->errorPQ()));
  Py_DecRef(pyval);

  pyval=PyFloat_FromDouble(self->klQP());
  PyDict_SetItemString(q,"klQP",PyFloat_FromDouble(self->klQP()));
  Py_DecRef(pyval);

  pyval=PyInt_FromLong(self->errorQP());
  PyDict_SetItemString(q,"errorQP",PyInt_FromLong(self->errorQP()));
  Py_DecRef(pyval);

  pyval=PyFloat_FromDouble(self->hellinger());
  PyDict_SetItemString(q,"hellinger",PyFloat_FromDouble(self->hellinger()));
  Py_DecRef(pyval);

  pyval=PyFloat_FromDouble(self->bhattacharya());
  PyDict_SetItemString(q,"bhattacharya",PyFloat_FromDouble(self->bhattacharya()));
  Py_DecRef(pyval);

  pyval=PyFloat_FromDouble(self->jsd());
  PyDict_SetItemString(q,"jensen-shannon",PyFloat_FromDouble(self->jsd()));
  Py_DecRef(pyval);

  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 PyObject *gum_learning_BNDatabaseGenerator_Sl_double_Sg__varOrder(gum::learning::BNDatabaseGenerator< double > const *self){ return PyAgrumHelper::PyTupleFromNodeVect(self->varOrder()); }
SWIGINTERN double gum_learning_BNDatabaseGenerator_Sl_double_Sg__drawSamples__SWIG_3(gum::learning::BNDatabaseGenerator< double > *self,gum::Size nbSamples,PyObject *arg){
    if (PyDict_Check(arg)) {
      gum::Instantiation inst;
      PyAgrumHelper::fillInstantiationFromPyObjectAndBN(&self->bn(), inst, arg);
      return self->drawSamples(nbSamples,inst);
    } else {
           {                                       std::ostringstream err_stream;        err_stream << "arg is neither a dict or an pyagrum.Instantiation.";                    throw(gum::InvalidArgument(err_stream.str()));      };
    }
  }
SWIGINTERN std::string gum_learning_BNLearner_Sl_double_Sg____repr__(gum::learning::BNLearner< double > const *self){
   std::stringstream s;
   s<<"(pyagrum.BNLearner@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_learning_BNLearner_Sl_double_Sg____str__(gum::learning::BNLearner< double > const *self){ return self->toString();}
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setVerbosity(gum::learning::BNLearner< double > *self,bool v){ self->gum::learning::IBNLearner::setVerbosity(v); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setEpsilon(gum::learning::BNLearner< double > *self,double eps){ self->gum::learning::IBNLearner::setEpsilon(eps); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setMinEpsilonRate(gum::learning::BNLearner< double > *self,double rate){ self->gum::learning::IBNLearner::setMinEpsilonRate(rate); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setMaxIter(gum::learning::BNLearner< double > *self,gum::Size max){ self->gum::learning::IBNLearner::setMaxIter(max); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setMaxTime(gum::learning::BNLearner< double > *self,double timeout){ self->gum::learning::IBNLearner::setMaxTime(timeout); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setPeriodSize(gum::learning::BNLearner< double > *self,gum::Size p){ self->gum::learning::IBNLearner::setPeriodSize(p); }
SWIGINTERN bool gum_learning_BNLearner_Sl_double_Sg__verbosity(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::verbosity(); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__epsilon(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::epsilon(); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__minEpsilonRate(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::minEpsilonRate(); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__maxIter(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::maxIter(); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__maxTime(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::maxTime(); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__periodSize(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::periodSize(); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__nbrIterations(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::nbrIterations(); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__currentTime(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::currentTime(); }
SWIGINTERN std::string gum_learning_BNLearner_Sl_double_Sg__messageApproximationScheme(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::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::IBNLearner::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::IBNLearner::learnDAG(); }
SWIGINTERN gum::PDAG gum_learning_BNLearner_Sl_double_Sg__learnPDAG(gum::learning::BNLearner< double > *self){ return self->gum::learning::IBNLearner::learnPDAG(); }
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::IBNLearner::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::IBNLearner::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::IBNLearner::nameFromId(id); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setDatabaseWeight(gum::learning::BNLearner< double > *self,double const new_weight){ self->gum::learning::IBNLearner::setDatabaseWeight(new_weight); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setRecordWeight(gum::learning::BNLearner< double > *self,std::size_t const i,double const weight){ self->gum::learning::IBNLearner::setRecordWeight(i,weight); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__databaseWeight(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::databaseWeight(); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__recordWeight(gum::learning::BNLearner< double > const *self,std::size_t const i){ return self->gum::learning::IBNLearner::recordWeight(i); }
SWIGINTERN bool gum_learning_BNLearner_Sl_double_Sg__hasMissingValues(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::hasMissingValues(); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__logLikelihood__SWIG_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::IBNLearner::logLikelihood(vars,knowing); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__logLikelihood__SWIG_1(gum::learning::BNLearner< double > *self,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &vars){ return self->gum::learning::IBNLearner::logLikelihood(vars); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__logLikelihood__SWIG_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::IBNLearner::logLikelihood(vars,knowing); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__logLikelihood__SWIG_3(gum::learning::BNLearner< double > *self,std::vector< std::string,std::allocator< std::string > > const &vars){ return self->gum::learning::IBNLearner::logLikelihood(vars); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__score__SWIG_0(gum::learning::BNLearner< double > *self,gum::NodeId vars,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &knowing={}){ return self->gum::learning::IBNLearner::score(vars,knowing); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__score__SWIG_1(gum::learning::BNLearner< double > *self,gum::NodeId vars){ return self->gum::learning::IBNLearner::score(vars); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__score__SWIG_2(gum::learning::BNLearner< double > *self,std::string const &vars,std::vector< std::string,std::allocator< std::string > > const &knowing={}){ return self->gum::learning::IBNLearner::score(vars,knowing); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__score__SWIG_3(gum::learning::BNLearner< double > *self,std::string const &vars){ return self->gum::learning::IBNLearner::score(vars); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__mutualInformation__SWIG_0(gum::learning::BNLearner< double > *self,gum::NodeId id1,gum::NodeId id2,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &knowing={}){ return self->gum::learning::IBNLearner::mutualInformation(id1,id2,knowing); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__mutualInformation__SWIG_1(gum::learning::BNLearner< double > *self,gum::NodeId id1,gum::NodeId id2){ return self->gum::learning::IBNLearner::mutualInformation(id1,id2); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__mutualInformation__SWIG_2(gum::learning::BNLearner< double > *self,std::string const &var1,std::string const &var2,std::vector< std::string,std::allocator< std::string > > const &knowing={}){ return self->gum::learning::IBNLearner::mutualInformation(var1,var2,knowing); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__mutualInformation__SWIG_3(gum::learning::BNLearner< double > *self,std::string const &var1,std::string const &var2){ return self->gum::learning::IBNLearner::mutualInformation(var1,var2); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__correctedMutualInformation__SWIG_0(gum::learning::BNLearner< double > *self,gum::NodeId id1,gum::NodeId id2,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &knowing={}){ return self->gum::learning::IBNLearner::correctedMutualInformation(id1,id2,knowing); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__correctedMutualInformation__SWIG_1(gum::learning::BNLearner< double > *self,gum::NodeId id1,gum::NodeId id2){ return self->gum::learning::IBNLearner::correctedMutualInformation(id1,id2); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__correctedMutualInformation__SWIG_2(gum::learning::BNLearner< double > *self,std::string const &var1,std::string const &var2,std::vector< std::string,std::allocator< std::string > > const &knowing={}){ return self->gum::learning::IBNLearner::correctedMutualInformation(var1,var2,knowing); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__correctedMutualInformation__SWIG_3(gum::learning::BNLearner< double > *self,std::string const &var1,std::string const &var2){ return self->gum::learning::IBNLearner::correctedMutualInformation(var1,var2); }
SWIGINTERN std::vector< double,std::allocator< double > > gum_learning_BNLearner_Sl_double_Sg__rawPseudoCount__SWIG_0(gum::learning::BNLearner< double > *self,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &vars){ return self->gum::learning::IBNLearner::rawPseudoCount(vars); }
SWIGINTERN std::vector< double,std::allocator< double > > gum_learning_BNLearner_Sl_double_Sg__rawPseudoCount__SWIG_1(gum::learning::BNLearner< double > *self,std::vector< std::string,std::allocator< std::string > > const &vars){ return self->gum::learning::IBNLearner::rawPseudoCount(vars); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__nbRows(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::nbRows(); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__nbCols(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::nbCols(); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__domainSize__SWIG_0(gum::learning::BNLearner< double > const *self,gum::NodeId var){ return self->gum::learning::IBNLearner::domainSize(var); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__domainSize__SWIG_1(gum::learning::BNLearner< double > const *self,std::string const &var){ return self->gum::learning::IBNLearner::domainSize(var); }
SWIGINTERN bool gum_learning_BNLearner_Sl_double_Sg__isUsingEM(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::isUsingEM(); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__EMEpsilon(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::EMEpsilon(); }
SWIGINTERN bool gum_learning_BNLearner_Sl_double_Sg__EMisEnabledEpsilon(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::EMisEnabledEpsilon(); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__EMMinEpsilonRate(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::EMMinEpsilonRate(); }
SWIGINTERN bool gum_learning_BNLearner_Sl_double_Sg__EMisEnabledMinEpsilonRate(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::EMisEnabledMinEpsilonRate(); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__EMMaxIter(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::EMMaxIter(); }
SWIGINTERN bool gum_learning_BNLearner_Sl_double_Sg__EMisEnabledMaxIter(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::EMisEnabledMaxIter(); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__EMMaxTime(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::EMMaxTime(); }
SWIGINTERN bool gum_learning_BNLearner_Sl_double_Sg__EMisEnabledMaxTime(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::EMisEnabledMaxTime(); }
SWIGINTERN bool gum_learning_BNLearner_Sl_double_Sg__EMVerbosity(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::EMVerbosity(); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__EMnbrIterations(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::EMnbrIterations(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_learning_BNLearner_Sl_double_Sg__EMHistory(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::EMHistory(); }
SWIGINTERN gum::IApproximationSchemeConfiguration::ApproximationSchemeSTATE gum_learning_BNLearner_Sl_double_Sg__EMStateApproximationScheme(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::EMStateApproximationScheme(); }
SWIGINTERN std::string gum_learning_BNLearner_Sl_double_Sg__EMStateMessage(gum::learning::BNLearner< double > const *self){ return self->gum::learning::IBNLearner::EMStateMessage(); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setNumberOfThreads(gum::learning::BNLearner< double > *self,gum::Size nb){ self->gum::learning::IBNLearner::setNumberOfThreads(nb); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__getNumberOfThreads(gum::learning::BNLearner< double > const *self){
     return self->getNumberOfThreads();
  }
SWIGINTERN bool gum_learning_BNLearner_Sl_double_Sg__isGumNumberOfThreadsOverriden(gum::learning::BNLearner< double > const *self){
     return self->isGumNumberOfThreadsOverriden();
  }
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 PyObject *gum_learning_BNLearner_Sl_double_Sg__G2__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->G2(var1,var2,knw);
    return Py_BuildValue("(dd)",res.first,res.second);
  }
SWIGINTERN bool gum_learning_BNLearner_Sl_double_Sg___EM_warning(gum::learning::BNLearner< double > const *self){
    return self->isUsingEM() &&
      (self->EMStateApproximationScheme() == gum::learning::BNLearner< double >::ApproximationSchemeSTATE::Stopped);
  }
SWIGINTERN gum::learning::BNLearner< double > &gum_learning_BNLearner_Sl_double_Sg__setSliceOrder__SWIG_2(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  *self;
    }

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

      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;
      }
    }
    self->setSliceOrder(ranks);
    return  *self;
  }
SWIGINTERN gum::learning::BNLearner< double > &gum_learning_BNLearner_Sl_double_Sg__useK2__SWIG_2(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  *self;
    }

    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  *self;
      }
      v.push_back((gum::NodeId)PyInt_AsLong(row));
    }

    self->useK2(v);
    return *self;
  }
SWIGINTERN PyObject *gum_learning_BNLearner_Sl_double_Sg__latentVariables(gum::learning::BNLearner< double > *self){
    return PyAgrumHelper::PyListFromArcVect(self->latentVariables());
  }
SWIGINTERN PyObject *gum_learning_BNLearner_Sl_double_Sg__state(gum::learning::BNLearner< double > *self){
    PyObject* res=PyDict_New();

    PyObject* pyval;
    for(const auto& tuple: self->state()) {
      pyval=Py_BuildValue("(ss)",std::get<1>(tuple).c_str(),std::get<2>(tuple).c_str());
      PyDict_SetItemString(res,std::get<0>(tuple).c_str(),pyval);
      Py_DecRef(pyval);
    }

    return res;
  }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setPossibleEdges__SWIG_1(gum::learning::BNLearner< double > *self,PyObject *soe){
    gum::EdgeSet set;
    PyAgrumHelper::fillEdgeSetFromPyObject(set,soe);
    self->setPossibleEdges(set);
  }

#include <agrum/cn.h>

SWIGINTERN std::string gum_credal_CredalNet_Sl_double_Sg____repr__(gum::credal::CredalNet< double > const *self){
   std::stringstream s;
   s<<"(pyagrum.CredalNet@"<<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 gum::Tensor< double > 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 gum::Tensor< double > 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 gum::Tensor< double > 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 gum::Tensor< double > 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_CNMonteCarloSampling_Sl_double_Sg__eraseAllEvidence(gum::credal::CNMonteCarloSampling< double > *self){
    self->gum::credal::InferenceEngine<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_0(gum::credal::CNMonteCarloSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::credal::InferenceEngine<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_1(gum::credal::CNMonteCarloSampling< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::credal::InferenceEngine<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_2(gum::credal::CNMonteCarloSampling< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::credal::InferenceEngine<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_3(gum::credal::CNMonteCarloSampling< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::credal::InferenceEngine<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_4(gum::credal::CNMonteCarloSampling< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
    self->gum::credal::InferenceEngine<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_5(gum::credal::CNMonteCarloSampling< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::credal::InferenceEngine<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_6(gum::credal::CNMonteCarloSampling< double > *self,gum::Tensor< double > const &p){
    self->gum::credal::InferenceEngine<double>::addEvidence(p);
  }
SWIGINTERN gum::credal::CredalNet< double > const &gum_credal_CNMonteCarloSampling_Sl_double_Sg__CN(gum::credal::CNMonteCarloSampling< double > const *self){ return self->gum::credal::InferenceEngine<double>::credalNet(); }
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 gum::Tensor< double > 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 gum::Tensor< double > 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 gum::Tensor< double > 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 gum::Tensor< double > 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 void gum_credal_CNLoopyPropagation_Sl_double_Sg__eraseAllEvidence(gum::credal::CNLoopyPropagation< double > *self){
    self->gum::credal::InferenceEngine<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__addEvidence__SWIG_0(gum::credal::CNLoopyPropagation< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::credal::InferenceEngine<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__addEvidence__SWIG_1(gum::credal::CNLoopyPropagation< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::credal::InferenceEngine<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__addEvidence__SWIG_2(gum::credal::CNLoopyPropagation< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::credal::InferenceEngine<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__addEvidence__SWIG_3(gum::credal::CNLoopyPropagation< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::credal::InferenceEngine<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__addEvidence__SWIG_4(gum::credal::CNLoopyPropagation< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
    self->gum::credal::InferenceEngine<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__addEvidence__SWIG_5(gum::credal::CNLoopyPropagation< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::credal::InferenceEngine<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__addEvidence__SWIG_6(gum::credal::CNLoopyPropagation< double > *self,gum::Tensor< double > const &p){
    self->gum::credal::InferenceEngine<double>::addEvidence(p);
  }
SWIGINTERN gum::credal::CredalNet< double > const &gum_credal_CNLoopyPropagation_Sl_double_Sg__CN(gum::credal::CNLoopyPropagation< double > const *self){ return self->gum::credal::InferenceEngine<double>::credalNet(); }

#include "extensions/IDGenerator.h"


#include <agrum/id.h>

SWIGINTERN PyObject *gum_InfluenceDiagram_Sl_double_Sg__names(gum::InfluenceDiagram< double > const *self){
     PyObject* q=PySet_New(0);

     PyObject* pyval;
     for ( auto node : self->nodes()) {
       pyval=PyString_FromString(self->variable(node).name().c_str());
       PySet_Add(q,pyval);
       Py_DecRef(pyval);
     }
     return q;
  }
SWIGINTERN PyObject *gum_InfluenceDiagram_Sl_double_Sg__nodes(gum::InfluenceDiagram< double > const *self){
    return PyAgrumHelper::PySetFromNodeSet(self->nodes());
  }
SWIGINTERN PyObject *gum_InfluenceDiagram_Sl_double_Sg__arcs(gum::InfluenceDiagram< double > const *self){
     return PyAgrumHelper::PySetFromArcSet(self->arcs());
   }
SWIGINTERN PyObject *gum_InfluenceDiagram_Sl_double_Sg__parents(gum::InfluenceDiagram< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->parents(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_InfluenceDiagram_Sl_double_Sg__children(gum::InfluenceDiagram< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->children(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_InfluenceDiagram_Sl_double_Sg__family(gum::InfluenceDiagram< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->family(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_InfluenceDiagram_Sl_double_Sg__descendants(gum::InfluenceDiagram< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->descendants(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyObject *gum_InfluenceDiagram_Sl_double_Sg__ancestors(gum::InfluenceDiagram< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->ancestors(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN gum::UndiGraph gum_InfluenceDiagram_Sl_double_Sg__moralizedAncestralGraph(gum::InfluenceDiagram< double > *self,PyObject *nodes){
     gum::NodeSet sonodes;
     PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sonodes,nodes,self->variableNodeMap());
     return self->moralizedAncestralGraph(sonodes);
   }
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<<"(pyagrum.InfluenceDiagram@"<<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 void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__makeInference(gum::ShaferShenoyLIMIDInference< double > *self){
    self->gum::ShaferShenoyLIMIDInference<double >::makeInference();
  }
SWIGINTERN gum::Tensor< double > const gum_ShaferShenoyLIMIDInference_Sl_double_Sg__posterior__SWIG_2(gum::ShaferShenoyLIMIDInference< double > *self,gum::NodeId const var){
    return self->gum::ShaferShenoyLIMIDInference<double >::posterior(var);
  }
SWIGINTERN gum::Tensor< double > const gum_ShaferShenoyLIMIDInference_Sl_double_Sg__posterior__SWIG_3(gum::ShaferShenoyLIMIDInference< double > *self,std::string const &nodeName){
    return self->gum::ShaferShenoyLIMIDInference<double >::posterior(nodeName);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__addEvidence__SWIG_0(gum::ShaferShenoyLIMIDInference< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::ShaferShenoyLIMIDInference<double >::addEvidence(id,val);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__addEvidence__SWIG_1(gum::ShaferShenoyLIMIDInference< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::ShaferShenoyLIMIDInference<double >::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__addEvidence__SWIG_2(gum::ShaferShenoyLIMIDInference< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::ShaferShenoyLIMIDInference<double >::addEvidence(id,val);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__addEvidence__SWIG_3(gum::ShaferShenoyLIMIDInference< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::ShaferShenoyLIMIDInference<double >::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__addEvidence__SWIG_4(gum::ShaferShenoyLIMIDInference< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::ShaferShenoyLIMIDInference<double >::addEvidence(id,vals);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__addEvidence__SWIG_5(gum::ShaferShenoyLIMIDInference< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::ShaferShenoyLIMIDInference<double >::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__addEvidence__SWIG_6(gum::ShaferShenoyLIMIDInference< double > *self,gum::Tensor< double > const &p){
    self->gum::ShaferShenoyLIMIDInference<double >::addEvidence(p);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__chgEvidence__SWIG_0(gum::ShaferShenoyLIMIDInference< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::ShaferShenoyLIMIDInference<double >::chgEvidence(id,val);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__chgEvidence__SWIG_1(gum::ShaferShenoyLIMIDInference< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::ShaferShenoyLIMIDInference<double >::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__chgEvidence__SWIG_2(gum::ShaferShenoyLIMIDInference< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::ShaferShenoyLIMIDInference<double >::chgEvidence(id,val);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__chgEvidence__SWIG_3(gum::ShaferShenoyLIMIDInference< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::ShaferShenoyLIMIDInference<double >::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__chgEvidence__SWIG_4(gum::ShaferShenoyLIMIDInference< double > *self,gum::Tensor< double > const &p){
    self->gum::ShaferShenoyLIMIDInference<double >::chgEvidence(p);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__chgEvidence__SWIG_5(gum::ShaferShenoyLIMIDInference< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::ShaferShenoyLIMIDInference<double >::chgEvidence(id,vals);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__chgEvidence__SWIG_6(gum::ShaferShenoyLIMIDInference< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::ShaferShenoyLIMIDInference<double >::chgEvidence(nodeName,vals);
  }
SWIGINTERN bool gum_ShaferShenoyLIMIDInference_Sl_double_Sg__hasEvidence__SWIG_0(gum::ShaferShenoyLIMIDInference< double > const *self,gum::NodeId const id){
    return self->gum::ShaferShenoyLIMIDInference<double >::hasEvidence(id);
  }
SWIGINTERN bool gum_ShaferShenoyLIMIDInference_Sl_double_Sg__hasEvidence__SWIG_1(gum::ShaferShenoyLIMIDInference< double > const *self,std::string const &nodeName){
    return self->gum::ShaferShenoyLIMIDInference<double >::hasEvidence(nodeName);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__eraseAllEvidence(gum::ShaferShenoyLIMIDInference< double > *self){
    self->gum::ShaferShenoyLIMIDInference<double >::eraseAllEvidence();
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__eraseEvidence__SWIG_0(gum::ShaferShenoyLIMIDInference< double > *self,gum::NodeId const id){
    self->gum::ShaferShenoyLIMIDInference<double >::eraseEvidence(id);
  }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__eraseEvidence__SWIG_1(gum::ShaferShenoyLIMIDInference< double > *self,std::string const &nodeName){
    self->gum::ShaferShenoyLIMIDInference<double >::eraseEvidence(nodeName);
  }
SWIGINTERN bool gum_ShaferShenoyLIMIDInference_Sl_double_Sg__hasSoftEvidence__SWIG_0(gum::ShaferShenoyLIMIDInference< double > const *self,gum::NodeId const id){
    return self->gum::ShaferShenoyLIMIDInference<double >::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_ShaferShenoyLIMIDInference_Sl_double_Sg__hasHardEvidence(gum::ShaferShenoyLIMIDInference< double > const *self,std::string const &nodeName){
    return self->gum::ShaferShenoyLIMIDInference<double >::hasHardEvidence(nodeName);
  }
SWIGINTERN bool gum_ShaferShenoyLIMIDInference_Sl_double_Sg__hasSoftEvidence__SWIG_1(gum::ShaferShenoyLIMIDInference< double > const *self,std::string const &nodeName){
    return self->gum::ShaferShenoyLIMIDInference<double >::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_ShaferShenoyLIMIDInference_Sl_double_Sg__nbrEvidence(gum::ShaferShenoyLIMIDInference< double > const *self){
    return self->gum::ShaferShenoyLIMIDInference<double >::nbrEvidence();
  }
SWIGINTERN gum::Size gum_ShaferShenoyLIMIDInference_Sl_double_Sg__nbrHardEvidence(gum::ShaferShenoyLIMIDInference< double > const *self){
    return self->gum::ShaferShenoyLIMIDInference<double >::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_ShaferShenoyLIMIDInference_Sl_double_Sg__nbrSoftEvidence(gum::ShaferShenoyLIMIDInference< double > const *self){
    return self->gum::ShaferShenoyLIMIDInference<double >::nbrSoftEvidence();
  }
SWIGINTERN gum::InfluenceDiagram< double > const &gum_ShaferShenoyLIMIDInference_Sl_double_Sg__influenceDiagram(gum::ShaferShenoyLIMIDInference< double > const *self){ return self->gum::InfluenceDiagramInference<double>::influenceDiagram(); }
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__setEvidence(gum::ShaferShenoyLIMIDInference< double > *self,PyObject *evidces){}
SWIGINTERN void gum_ShaferShenoyLIMIDInference_Sl_double_Sg__updateEvidence(gum::ShaferShenoyLIMIDInference< double > *self,PyObject *evidces){}
SWIGINTERN PyObject *gum_ShaferShenoyLIMIDInference_Sl_double_Sg__hardEvidenceNodes(gum::ShaferShenoyLIMIDInference< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_ShaferShenoyLIMIDInference_Sl_double_Sg__softEvidenceNodes(gum::ShaferShenoyLIMIDInference< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_ShaferShenoyLIMIDInference_Sl_double_Sg__MEU__SWIG_1(gum::ShaferShenoyLIMIDInference< double > *self){
    std::cout<<"H"<<std::endl;
      return PyAgrumHelper::PyDictFromPairMeanVar(self->MEU() ) ;
    }
SWIGINTERN PyObject *gum_ShaferShenoyLIMIDInference_Sl_double_Sg__meanVar__SWIG_2(gum::ShaferShenoyLIMIDInference< double > *self,gum::NodeId node){
      return PyAgrumHelper::PyDictFromPairMeanVar(self->meanVar(node) ) ;
    }

#include <agrum/mrf.h>

SWIGINTERN PyObject *gum_IMarkovRandomField_Sl_double_Sg__names(gum::IMarkovRandomField< double > const *self){
     PyObject* q=PySet_New(0);

     PyObject* pyval;
     for ( auto node : self->nodes()) {
       pyval=PyString_FromString(self->variable(node).name().c_str());
       PySet_Add(q,pyval);
       Py_DecRef(pyval);
     }
     return q;
  }
SWIGINTERN PyObject *gum_IMarkovRandomField_Sl_double_Sg__nodes(gum::IMarkovRandomField< double > const *self){
    return PyAgrumHelper::PySetFromNodeSet(self->nodes());
  }
SWIGINTERN PyObject *gum_IMarkovRandomField_Sl_double_Sg__neighbours(gum::IMarkovRandomField< double > const *self,PyObject *norid){
    return PyAgrumHelper::PySetFromNodeSet(self->neighbours(
       PyAgrumHelper::nodeIdFromNameOrIndex(norid, self->variableNodeMap())));
  }
SWIGINTERN PyObject *gum_IMarkovRandomField_Sl_double_Sg__edges(gum::IMarkovRandomField< double > const *self){
    return PyAgrumHelper::PySetFromEdgeSet(self->graph().edges());
  }
SWIGINTERN PyObject *gum_IMarkovRandomField_Sl_double_Sg__minimalCondSet__SWIG_2(gum::IMarkovRandomField< double > const *self,gum::NodeId target,PyObject *list){
    gum::NodeSet soids;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soids,list,self->variableNodeMap());
    return PyAgrumHelper::PySetFromNodeSet(self->minimalCondSet(target, soids));
  }
SWIGINTERN PyObject *gum_IMarkovRandomField_Sl_double_Sg__minimalCondSet__SWIG_3(gum::IMarkovRandomField< double > const *self,PyObject *targets,PyObject *list){
    gum::NodeSet sotargets;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sotargets,targets,self->variableNodeMap());

    gum::NodeSet soids;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soids,list,self->variableNodeMap());
    return PyAgrumHelper::PySetFromNodeSet(self->minimalCondSet(sotargets, soids));
  }
SWIGINTERN gum::Tensor< double > const &gum_IMarkovRandomField_Sl_double_Sg__factor__SWIG_1(gum::IMarkovRandomField< double > const *self,PyObject *nodeseq){
    gum::NodeSet idx;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(idx,nodeseq,self->variableNodeMap());

    return self->factor(idx);
  }
SWIGINTERN bool gum_IMarkovRandomField_Sl_double_Sg__isIndependent__SWIG_0(gum::IMarkovRandomField< double > *self,PyObject *X,PyObject *Y,PyObject *Z){
     gum::NodeSet nx,ny,nz;
     PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nx,X,self->variableNodeMap());
     PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(ny,Y,self->variableNodeMap());
     PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nz,Z,self->variableNodeMap());
     return self->isIndependent(nx,ny,nz);
   }
SWIGINTERN bool gum_IMarkovRandomField_Sl_double_Sg__isIndependent__SWIG_1(gum::IMarkovRandomField< double > *self,PyObject *X,PyObject *Y){
     gum::NodeSet nx,ny,nz;
     PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nx,X,self->variableNodeMap());
     PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(ny,Y,self->variableNodeMap());
     return self->isIndependent(nx,ny,nz);
   }
SWIGINTERN std::string gum_IMarkovRandomField_Sl_double_Sg____repr__(gum::IMarkovRandomField< double > const *self){
   std::stringstream s;
   s<<"(pyagrum.IMarkovRandomField@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_IMarkovRandomField_Sl_double_Sg____str__(gum::IMarkovRandomField< double > const *self){ return self->toString();}
SWIGINTERN PyObject *gum_MarkovRandomField_Sl_double_Sg__names(gum::MarkovRandomField< double > const *self){
     PyObject* q=PySet_New(0);

     PyObject* pyval;
     for ( auto node : self->nodes()) {
       pyval=PyString_FromString(self->variable(node).name().c_str());
       PySet_Add(q,pyval);
       Py_DecRef(pyval);
     }
     return q;
  }
SWIGINTERN PyObject *gum_MarkovRandomField_Sl_double_Sg__nodes(gum::MarkovRandomField< double > const *self){
    return PyAgrumHelper::PySetFromNodeSet(self->nodes());
  }
SWIGINTERN PyObject *gum_MarkovRandomField_Sl_double_Sg__neighbours(gum::MarkovRandomField< double > const *self,PyObject *norid){
    return PyAgrumHelper::PySetFromNodeSet(self->neighbours(
       PyAgrumHelper::nodeIdFromNameOrIndex(norid, self->variableNodeMap())));
  }
SWIGINTERN PyObject *gum_MarkovRandomField_Sl_double_Sg__edges(gum::MarkovRandomField< double > const *self){
    return PyAgrumHelper::PySetFromEdgeSet(self->graph().edges());
  }
SWIGINTERN PyObject *gum_MarkovRandomField_Sl_double_Sg__minimalCondSet__SWIG_0(gum::MarkovRandomField< double > const *self,gum::NodeId target,PyObject *list){
    gum::NodeSet soids;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soids,list,self->variableNodeMap());
    return PyAgrumHelper::PySetFromNodeSet(self->minimalCondSet(target, soids));
  }
SWIGINTERN PyObject *gum_MarkovRandomField_Sl_double_Sg__minimalCondSet__SWIG_1(gum::MarkovRandomField< double > const *self,PyObject *targets,PyObject *list){
    gum::NodeSet sotargets;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sotargets,targets,self->variableNodeMap());

    gum::NodeSet soids;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soids,list,self->variableNodeMap());
    return PyAgrumHelper::PySetFromNodeSet(self->minimalCondSet(sotargets, soids));
  }
SWIGINTERN gum::Tensor< double > const &gum_MarkovRandomField_Sl_double_Sg__factor__SWIG_2(gum::MarkovRandomField< double > const *self,PyObject *nodeseq){
    gum::NodeSet idx;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(idx,nodeseq,self->variableNodeMap());

    return self->factor(idx);
  }
SWIGINTERN bool gum_MarkovRandomField_Sl_double_Sg__isIndependent__SWIG_0(gum::MarkovRandomField< double > *self,PyObject *X,PyObject *Y,PyObject *Z){
     gum::NodeSet nx,ny,nz;
     PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nx,X,self->variableNodeMap());
     PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(ny,Y,self->variableNodeMap());
     PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nz,Z,self->variableNodeMap());
     return self->isIndependent(nx,ny,nz);
   }
SWIGINTERN bool gum_MarkovRandomField_Sl_double_Sg__isIndependent__SWIG_1(gum::MarkovRandomField< double > *self,PyObject *X,PyObject *Y){
     gum::NodeSet nx,ny,nz;
     PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nx,X,self->variableNodeMap());
     PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(ny,Y,self->variableNodeMap());
     return self->isIndependent(nx,ny,nz);
   }
SWIGINTERN std::string gum_MarkovRandomField_Sl_double_Sg__loadUAI__SWIG_0(gum::MarkovRandomField< double > *self,std::string name,PyObject *l=(PyObject *) 0){
     std::stringstream stream;
     std::vector<PythonLoadListener> py_listener;

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

       auto nbErr=reader.proceed();
       reader.showElegantErrorsAndWarnings(stream);
       if (nbErr>0) {
         reader.showErrorCounts(stream);
              {                                       std::ostringstream err_stream;        err_stream << stream.str();                    throw(gum::FatalError(err_stream.str()));      }
       } else {
         return stream.str();
       }
     } catch (gum::IOError& e) {
       throw(e);
     }
     return "";
   }
SWIGINTERN void gum_MarkovRandomField_Sl_double_Sg__saveUAI(gum::MarkovRandomField< double > *self,std::string name){
     gum::UAIMRFWriter<double> writer;
     writer.write( name, *self );
   }
SWIGINTERN std::string gum_MarkovRandomField_Sl_double_Sg____repr__(gum::MarkovRandomField< double > const *self){
   std::stringstream s;
   s<<"(pyagrum.MarkovRandomField@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_MarkovRandomField_Sl_double_Sg____str__(gum::MarkovRandomField< double > const *self){ return self->toString();}
SWIGINTERN gum::Tensor< double > const &gum_MarkovRandomField_Sl_double_Sg__addFactor__SWIG_3(gum::MarkovRandomField< double > *self,PyObject *seq){
      if (PyList_Check(seq)) {
        std::vector<std::string> names;
        PyAgrumHelper::populateStrVectorFromPySequenceOfIntOrString(names,seq,self->variableNodeMap());
        return self->addFactor(names);
      } else {
        gum::NodeSet son;
        PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(son,seq,self->variableNodeMap());
        return self->addFactor(son);
      }
    }
SWIGINTERN void gum_MarkovRandomField_Sl_double_Sg__eraseFactor__SWIG_2(gum::MarkovRandomField< double > *self,PyObject *seq){
      gum::NodeSet son;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(son,seq,self->variableNodeMap());
      self->eraseFactor(son);
    }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__setNumberOfThreads(gum::ShaferShenoyMRFInference< double > *self,int nb){
    self->setNumberOfThreads(nb);
  }
SWIGINTERN int gum_ShaferShenoyMRFInference_Sl_double_Sg__getNumberOfThreads(gum::ShaferShenoyMRFInference< double > *self){
    return self->getNumberOfThreads();
  }
SWIGINTERN bool gum_ShaferShenoyMRFInference_Sl_double_Sg__isGumNumberOfThreadsOverriden(gum::ShaferShenoyMRFInference< double > *self){
    return self->isGumNumberOfThreadsOverriden();
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__setMaxMemory(gum::ShaferShenoyMRFInference< double > *self,int gigabytes){
    self->setMaxMemory(gigabytes);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__makeInference(gum::ShaferShenoyMRFInference< double > *self){
    self->gum::MarginalTargetedMRFInference<double>::makeInference();
  }
SWIGINTERN gum::Tensor< double > const gum_ShaferShenoyMRFInference_Sl_double_Sg__posterior__SWIG_0(gum::ShaferShenoyMRFInference< double > *self,gum::NodeId const var){
    return self->gum::MarginalTargetedMRFInference<double>::posterior(var);
  }
SWIGINTERN gum::Tensor< double > const gum_ShaferShenoyMRFInference_Sl_double_Sg__posterior__SWIG_1(gum::ShaferShenoyMRFInference< double > *self,std::string const &nodeName){
    return self->gum::MarginalTargetedMRFInference<double>::posterior(nodeName);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__addEvidence__SWIG_0(gum::ShaferShenoyMRFInference< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedMRFInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__addEvidence__SWIG_1(gum::ShaferShenoyMRFInference< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::MarginalTargetedMRFInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__addEvidence__SWIG_2(gum::ShaferShenoyMRFInference< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::MarginalTargetedMRFInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__addEvidence__SWIG_3(gum::ShaferShenoyMRFInference< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::MarginalTargetedMRFInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__addEvidence__SWIG_4(gum::ShaferShenoyMRFInference< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::MarginalTargetedMRFInference<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__addEvidence__SWIG_5(gum::ShaferShenoyMRFInference< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::MarginalTargetedMRFInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__addEvidence__SWIG_6(gum::ShaferShenoyMRFInference< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedMRFInference<double>::addEvidence(p);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__chgEvidence__SWIG_0(gum::ShaferShenoyMRFInference< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::MarginalTargetedMRFInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__chgEvidence__SWIG_1(gum::ShaferShenoyMRFInference< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::MarginalTargetedMRFInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__chgEvidence__SWIG_2(gum::ShaferShenoyMRFInference< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::MarginalTargetedMRFInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__chgEvidence__SWIG_3(gum::ShaferShenoyMRFInference< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::MarginalTargetedMRFInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__chgEvidence__SWIG_4(gum::ShaferShenoyMRFInference< double > *self,gum::Tensor< double > const &p){
    self->gum::MarginalTargetedMRFInference<double>::chgEvidence(p);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__chgEvidence__SWIG_5(gum::ShaferShenoyMRFInference< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::MarginalTargetedMRFInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__chgEvidence__SWIG_6(gum::ShaferShenoyMRFInference< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::MarginalTargetedMRFInference<double>::chgEvidence(nodeName,vals);
  }
SWIGINTERN bool gum_ShaferShenoyMRFInference_Sl_double_Sg__hasEvidence__SWIG_0(gum::ShaferShenoyMRFInference< double > const *self,gum::NodeId const id){
    return self->gum::MarginalTargetedMRFInference<double>::hasEvidence(id);
  }
SWIGINTERN bool gum_ShaferShenoyMRFInference_Sl_double_Sg__hasEvidence__SWIG_1(gum::ShaferShenoyMRFInference< double > const *self,std::string const &nodeName){
    return self->gum::MarginalTargetedMRFInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__eraseAllEvidence(gum::ShaferShenoyMRFInference< double > *self){
    self->gum::MarginalTargetedMRFInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__eraseEvidence__SWIG_0(gum::ShaferShenoyMRFInference< double > *self,gum::NodeId const id){
    self->gum::MarginalTargetedMRFInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__eraseEvidence__SWIG_1(gum::ShaferShenoyMRFInference< double > *self,std::string const &nodeName){
    self->gum::MarginalTargetedMRFInference<double>::eraseEvidence(nodeName);
  }
SWIGINTERN bool gum_ShaferShenoyMRFInference_Sl_double_Sg__hasSoftEvidence__SWIG_0(gum::ShaferShenoyMRFInference< double > const *self,gum::NodeId const id){
    return self->gum::MarginalTargetedMRFInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_ShaferShenoyMRFInference_Sl_double_Sg__hasHardEvidence(gum::ShaferShenoyMRFInference< double > const *self,std::string const &nodeName){
    return self->gum::MarginalTargetedMRFInference<double>::hasHardEvidence(nodeName);
  }
SWIGINTERN bool gum_ShaferShenoyMRFInference_Sl_double_Sg__hasSoftEvidence__SWIG_1(gum::ShaferShenoyMRFInference< double > const *self,std::string const &nodeName){
    return self->gum::MarginalTargetedMRFInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_ShaferShenoyMRFInference_Sl_double_Sg__nbrEvidence(gum::ShaferShenoyMRFInference< double > const *self){
    return self->gum::MarginalTargetedMRFInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_ShaferShenoyMRFInference_Sl_double_Sg__nbrHardEvidence(gum::ShaferShenoyMRFInference< double > const *self){
    return self->gum::MarginalTargetedMRFInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_ShaferShenoyMRFInference_Sl_double_Sg__nbrSoftEvidence(gum::ShaferShenoyMRFInference< double > const *self){
    return self->gum::MarginalTargetedMRFInference<double>::nbrSoftEvidence();
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__eraseAllTargets(gum::ShaferShenoyMRFInference< double > *self){
      self->gum::MarginalTargetedMRFInference<double>::eraseAllTargets();
    }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__addAllTargets(gum::ShaferShenoyMRFInference< double > *self){
      self->gum::MarginalTargetedMRFInference<double>::addAllTargets();
    }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__addTarget__SWIG_0(gum::ShaferShenoyMRFInference< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedMRFInference<double>::addTarget(target);
    }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__addTarget__SWIG_1(gum::ShaferShenoyMRFInference< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedMRFInference<double>::addTarget(nodeName);
    }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__eraseTarget__SWIG_0(gum::ShaferShenoyMRFInference< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedMRFInference<double>::eraseTarget(target);
    }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__eraseTarget__SWIG_1(gum::ShaferShenoyMRFInference< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedMRFInference<double>::eraseTarget(nodeName);
    }
SWIGINTERN bool gum_ShaferShenoyMRFInference_Sl_double_Sg__isTarget__SWIG_0(gum::ShaferShenoyMRFInference< double > const *self,gum::NodeId const variable){
      return self->gum::MarginalTargetedMRFInference<double>::isTarget(variable);
    }
SWIGINTERN bool gum_ShaferShenoyMRFInference_Sl_double_Sg__isTarget__SWIG_1(gum::ShaferShenoyMRFInference< double > const *self,std::string const &nodeName){
      return self->gum::MarginalTargetedMRFInference<double>::isTarget(nodeName);
    }
SWIGINTERN gum::Size gum_ShaferShenoyMRFInference_Sl_double_Sg__nbrTargets(gum::ShaferShenoyMRFInference< double > const *self){
      return self->gum::MarginalTargetedMRFInference<double>::nbrTargets();
    }
SWIGINTERN double gum_ShaferShenoyMRFInference_Sl_double_Sg__H__SWIG_0(gum::ShaferShenoyMRFInference< double > *self,gum::NodeId const X){
     return self->gum::MarginalTargetedMRFInference<double>::H(X);
   }
SWIGINTERN double gum_ShaferShenoyMRFInference_Sl_double_Sg__H__SWIG_1(gum::ShaferShenoyMRFInference< double > *self,std::string const &nodeName){
     return self->gum::MarginalTargetedMRFInference<double>::H(nodeName);
   }
SWIGINTERN gum::Tensor< double > gum_ShaferShenoyMRFInference_Sl_double_Sg__evidenceImpact__SWIG_0(gum::ShaferShenoyMRFInference< double > *self,gum::NodeId target,gum::NodeSet const &evs){
    return self->gum::MarginalTargetedMRFInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Tensor< double > gum_ShaferShenoyMRFInference_Sl_double_Sg__evidenceImpact__SWIG_1(gum::ShaferShenoyMRFInference< double > *self,std::string const &target,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::MarginalTargetedMRFInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::IMarkovRandomField< double > const &gum_ShaferShenoyMRFInference_Sl_double_Sg__MRF(gum::ShaferShenoyMRFInference< double > const *self){ return self->gum::MarginalTargetedMRFInference<double>::MRF(); }
SWIGINTERN gum::Tensor< double > const gum_ShaferShenoyMRFInference_Sl_double_Sg__posterior__SWIG_2(gum::ShaferShenoyMRFInference< double > *self,std::string const nodeName){
    return self->JointTargetedMRFInference<double>::posterior(nodeName);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__eraseAllJointTargets(gum::ShaferShenoyMRFInference< double > *self){
    self->gum::JointTargetedMRFInference<double>::eraseAllJointTargets();
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__eraseAllMarginalTargets(gum::ShaferShenoyMRFInference< double > *self){
    self->gum::JointTargetedMRFInference<double>::eraseAllMarginalTargets();
  }
SWIGINTERN gum::Size gum_ShaferShenoyMRFInference_Sl_double_Sg__nbrJointTargets(gum::ShaferShenoyMRFInference< double > *self){
    return self->gum::JointTargetedMRFInference<double>::nbrJointTargets();
  }
SWIGINTERN gum::Tensor< double > gum_ShaferShenoyMRFInference_Sl_double_Sg__evidenceJointImpact__SWIG_0(gum::ShaferShenoyMRFInference< double > *self,gum::NodeSet const &targets,gum::NodeSet const &evs){
    return self->gum::JointTargetedMRFInference<double>::evidenceJointImpact(targets,evs);
  }
SWIGINTERN gum::Tensor< double > gum_ShaferShenoyMRFInference_Sl_double_Sg__evidenceJointImpact__SWIG_1(gum::ShaferShenoyMRFInference< 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::JointTargetedMRFInference<double>::evidenceJointImpact(targets,evs);
  }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__setEvidence(gum::ShaferShenoyMRFInference< double > *self,PyObject *evidces){}
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__updateEvidence(gum::ShaferShenoyMRFInference< double > *self,PyObject *evidces){}
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__setTargets(gum::ShaferShenoyMRFInference< double > *self,PyObject *targets){}
SWIGINTERN PyObject *gum_ShaferShenoyMRFInference_Sl_double_Sg__hardEvidenceNodes(gum::ShaferShenoyMRFInference< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_ShaferShenoyMRFInference_Sl_double_Sg__softEvidenceNodes(gum::ShaferShenoyMRFInference< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_ShaferShenoyMRFInference_Sl_double_Sg__targets(gum::ShaferShenoyMRFInference< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->targets() );
    }
SWIGINTERN gum::Tensor< double > gum_ShaferShenoyMRFInference_Sl_double_Sg__evidenceImpact__SWIG_2(gum::ShaferShenoyMRFInference< double > *self,PyObject *target,PyObject *evs){
      gum::NodeId itarget=PyAgrumHelper::nodeIdFromNameOrIndex(target,self->MRF().variableNodeMap());
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->MRF().variableNodeMap());
      return self->evidenceImpact(itarget,soe);
    }
SWIGINTERN double gum_ShaferShenoyMRFInference_Sl_double_Sg__jointMutualInformation(gum::ShaferShenoyMRFInference< double > *self,PyObject *targets){
      gum::NodeSet sot;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sot,targets,self->MRF().variableNodeMap());
      return self->jointMutualInformation(sot);
    }
SWIGINTERN gum::Tensor< double > gum_ShaferShenoyMRFInference_Sl_double_Sg__evidenceJointImpact__SWIG_2(gum::ShaferShenoyMRFInference< double > *self,PyObject *targets,PyObject *evs){
      gum::NodeSet sot;
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sot,targets,self->MRF().variableNodeMap());
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->MRF().variableNodeMap());
      return self->evidenceJointImpact(sot,soe);
    }
SWIGINTERN gum::Tensor< double > gum_ShaferShenoyMRFInference_Sl_double_Sg__jointPosterior(gum::ShaferShenoyMRFInference< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->MRF().variableNodeMap());
      return self->jointPosterior(nodeset);
    }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__addJointTarget(gum::ShaferShenoyMRFInference< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->MRF().variableNodeMap());

      self->gum::JointTargetedMRFInference<double>::addJointTarget(nodeset);
    }
SWIGINTERN void gum_ShaferShenoyMRFInference_Sl_double_Sg__eraseJointTarget(gum::ShaferShenoyMRFInference< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->MRF().variableNodeMap());
      self->gum::JointTargetedMRFInference<double>::eraseJointTarget(nodeset);
    }
SWIGINTERN bool gum_ShaferShenoyMRFInference_Sl_double_Sg__isJointTarget(gum::ShaferShenoyMRFInference< double > *self,PyObject *targets){
      if (! PyAnySet_Check(targets)) {
             {                                       std::ostringstream err_stream;        err_stream << "The argument must be a set";                    throw(gum::InvalidArgument(err_stream.str()));      }
      }
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,targets,self->MRF().variableNodeMap());
      return self->gum::JointTargetedMRFInference<double>::isJointTarget(nodeset);
    }
SWIGINTERN PyObject *gum_ShaferShenoyMRFInference_Sl_double_Sg__jointTargets(gum::ShaferShenoyMRFInference< double > const *self){
      PyObject* q = PyList_New( 0 );

      PyObject* pyval;
      for ( auto ns : self->JointTargetedMRFInference<double>::jointTargets()) {
        pyval=PyAgrumHelper::PySetFromNodeSet(ns);
        PyList_Append( q, pyval );
        Py_DecRef( pyval );
      }
      return q;
    }


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

#include "pyagrumPYTHON_wrap.h"

#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_SwigPyIterator_incr__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_SwigPyIterator_incr__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ptrdiff_t result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  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 +=(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  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 -=(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  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 +(SWIG_STD_MOVE(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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  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 -(SWIG_STD_MOVE(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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ptrdiff_t result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::UndiGraph *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  (void)self;
  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_NullReferenceError, "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(result)), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_junctionTree__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::UndiGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  (void)self;
  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_NullReferenceError, "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(result)), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_junctionTree__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::DAG *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  (void)self;
  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_NullReferenceError, "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(result)), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_junctionTree__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::DAG *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  (void)self;
  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_NullReferenceError, "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(result)), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_junctionTree__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  (void)self;
  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_NullReferenceError, "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(result)), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_junctionTree__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  (void)self;
  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_NullReferenceError, "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(result)), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_junctionTree__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::MarkovRandomField< double > *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  (void)self;
  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__MarkovRandomFieldT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::MarkovRandomField< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::MarkovRandomField< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp2);
  arg3 = swig_obj[2];
  {
    try {
      result = ((JunctionTreeGenerator const *)arg1)->junctionTree((gum::MarkovRandomField< double > const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::JunctionTree(result)), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_junctionTree__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::MarkovRandomField< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  (void)self;
  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__MarkovRandomFieldT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::MarkovRandomField< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::MarkovRandomField< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp2);
  {
    try {
      result = ((JunctionTreeGenerator const *)arg1)->junctionTree((gum::MarkovRandomField< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_JunctionTreeGenerator_junctionTree__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_JunctionTreeGenerator_junctionTree__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_JunctionTreeGenerator_junctionTree__SWIG_5(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_JunctionTreeGenerator_junctionTree__SWIG_7(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_JunctionTreeGenerator_junctionTree__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    PyObject *retobj = _wrap_JunctionTreeGenerator_junctionTree__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_6:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_7;
    PyObject *retobj = _wrap_JunctionTreeGenerator_junctionTree__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_7:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_JunctionTreeGenerator_junctionTree__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    JunctionTreeGenerator::junctionTree(gum::MarkovRandomField< double > const &,PyObject *) const\n"
    "    JunctionTreeGenerator::junctionTree(gum::MarkovRandomField< double > const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_eliminationOrder__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::UndiGraph *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::UndiGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::DAG *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::DAG *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_JunctionTreeGenerator_eliminationOrder__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_JunctionTreeGenerator_eliminationOrder__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_JunctionTreeGenerator_eliminationOrder__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    PyObject *retobj = _wrap_JunctionTreeGenerator_eliminationOrder__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_JunctionTreeGenerator_eliminationOrder__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_JunctionTreeGenerator_eliminationOrder__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::UndiGraph *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  (void)self;
  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_NullReferenceError, "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(result)), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::UndiGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  (void)self;
  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_NullReferenceError, "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(result)), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::DAG *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  (void)self;
  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_NullReferenceError, "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(result)), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::DAG *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  (void)self;
  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_NullReferenceError, "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(result)), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  (void)self;
  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_NullReferenceError, "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(result)), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  (void)self;
  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_NullReferenceError, "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(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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    PyObject *retobj = _wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_Vector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 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 ;
  
  (void)self;
  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_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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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_NullReferenceError, "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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_Vector___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Vector___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 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] ;
  
  (void)self;
  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_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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) 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_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) 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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) 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 = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Vector___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Vector___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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,SWIG_STD_MOVE(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));
  (void)swig::container_owner<swig::traits<std::vector< double >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  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 = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Vector___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Vector___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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,SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_Vector___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Vector___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Vector___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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__(SWIGPY_SLICEOBJECT *,std::vector< double,std::allocator< double > > const &)\n"
    "    std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *)\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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 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] ;
  
  (void)self;
  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_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 *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< double > *result = 0 ;
  
  (void)self;
  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_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector__SWIG_1(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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_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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< double > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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(result)), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector__SWIG_2(PyObject *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 ;
  
  (void)self;
  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 >(SWIG_STD_MOVE(arg1));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< double >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 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;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_Vector_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Vector_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *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 ;
  
  (void)self;
  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 >(SWIG_STD_MOVE(arg1),(std::vector< double >::value_type const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_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) {
    PyObject *retobj = _wrap_new_Vector__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_Vector__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Vector__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Vector__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 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] ;
  
  (void)self;
  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_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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));
  (void)swig::container_owner<swig::traits<std::vector< double >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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));
  (void)swig::container_owner<swig::traits<std::vector< double >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 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] ;
  
  (void)self;
  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_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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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(SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_Vector_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Vector_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 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;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_Vector_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Vector_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_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 = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_double_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_uint_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint___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_uint___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint___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_uint___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint___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_uint___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 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 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Vector_uint___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint___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_uint___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_uint___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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_uint___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint___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_uint___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_uint___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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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_uint___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint___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_uint___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_uint___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_uint___setslice__" "', argument " "4"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Vector_uint___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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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_uint___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_uint___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Vector_uint___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Vector_uint___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_uint___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_uint___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Vector_uint___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint___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_uint___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_uint___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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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_uint___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint___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_uint___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,SWIG_STD_MOVE(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_uint___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint___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_uint___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) 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_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_uint___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint___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_uint___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) 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_uint___setitem__" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Vector_uint___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_uint___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint___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_uint___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) 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_uint___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint___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_uint___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) 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_uint___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_uint___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Vector_uint___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Vector_uint___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_uint___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__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_uint___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint___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_uint___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,SWIG_STD_MOVE(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));
  (void)swig::container_owner<swig::traits<std::vector< unsigned int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_uint___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_uint___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Vector_uint___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Vector_uint___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_uint___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< unsigned int >::__getitem__(std::vector< unsigned int >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_uint___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint___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_uint___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_uint___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,SWIG_STD_MOVE(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_uint___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_uint___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Vector_uint___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Vector_uint___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Vector_uint___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_uint___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n"
    "    std::vector< unsigned int >::__setitem__(SWIGPY_SLICEOBJECT *)\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_uint_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Vector_uint_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_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_uint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *result = 0 ;
  
  (void)self;
  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_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector_uint__SWIG_1(PyObject *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 ;
  
  (void)self;
  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_uint" "', argument " "1"" of type '" "std::vector< unsigned int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Vector_uint" "', 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_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_uint_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Vector_uint_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_uint_swap" "', argument " "2"" of type '" "std::vector< unsigned int > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Vector_uint_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_uint_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< unsigned int > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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(result)), SWIGTYPE_p_std__allocatorT_unsigned_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector_uint__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_uint" "', 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 >(SWIG_STD_MOVE(arg1));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_Vector_uint_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 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;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_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_uint_erase" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_unsigned_SS_int_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(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_uint_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 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;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_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_uint_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_uint_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_uint_erase" "', argument " "3"" of type '" "std::vector< unsigned int >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_unsigned_SS_int_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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_uint_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_uint_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Vector_uint_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Vector_uint_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_uint_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_uint__SWIG_3(PyObject *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 ;
  
  (void)self;
  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_uint" "', 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_uint" "', 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 >(SWIG_STD_MOVE(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_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector_uint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Vector_uint", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_Vector_uint__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_Vector_uint__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Vector_uint__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Vector_uint__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Vector_uint'.\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_uint_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Vector_uint_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_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_uint_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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));
  (void)swig::container_owner<swig::traits<std::vector< unsigned int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_uint_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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));
  (void)swig::container_owner<swig::traits<std::vector< unsigned int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_uint_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Vector_uint_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_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_uint_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(SWIG_STD_MOVE(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_uint_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_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_uint_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(SWIG_STD_MOVE(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_uint_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_uint_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Vector_uint_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Vector_uint_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_uint_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_uint_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 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;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_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_uint_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_uint_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,SWIG_STD_MOVE(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_uint_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_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_uint_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_uint_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_uint_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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(unsigned int const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_uint_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_uint_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Vector_uint_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Vector_uint_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_uint_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_uint_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Vector_uint_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint_reserve" "', argument " "2"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_uint_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_uint_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_uint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vector_uint" "', 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_uint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

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

SWIGINTERN PyObject *_wrap_Vector_int_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_iterator" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___bool__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_int_Sg____bool__((std::vector< 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___len__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = std_vector_Sl_int_Sg____len__((std::vector< 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< 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< int,std::allocator< int > > *result = 0 ;
  
  (void)self;
  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_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< 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< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< 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< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< 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< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< 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< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  std::vector< int,std::allocator< 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 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< 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< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< 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< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< 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< int,std::allocator< int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Vector_int___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_int_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< int,std::allocator< 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) {
    PyObject *retobj = _wrap_Vector_int___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Vector_int___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type)\n"
    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type,std::vector< int,std::allocator< int > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_int___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< 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] ;
  
  (void)self;
  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_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< 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< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< 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< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_int_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< 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< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_int_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___getitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_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_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< int,std::allocator< int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< 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< int,std::allocator< int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Vector_int___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< int,std::allocator< 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_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 = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Vector_int___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Vector_int___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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< int >::__delitem__(std::vector< int >::difference_type)\n"
    "    std::vector< int >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_int___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< 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< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg____getitem____SWIG_1((std::vector< int > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(*result));
  (void)swig::container_owner<swig::traits<std::vector< int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  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 = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Vector_int___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Vector_int___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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< int >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_int___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< 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< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_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< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      try {
        std_vector_Sl_int_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(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) {
    PyObject *retobj = _wrap_Vector_int___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Vector_int___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Vector_int___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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< int >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< int,std::allocator< int > > const &)\n"
    "    std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_Vector_int_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< int >::value_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_append" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_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< int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      std_vector_Sl_int_Sg__append(arg1,(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 *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< int > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< int > *)new std::vector< int >();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector_int__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< int > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< 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< int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Vector_int" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_empty" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (bool)((std::vector< 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_size" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = ((std::vector< 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_swap" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_int_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Vector_int_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_begin" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


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


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


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


SWIGINTERN PyObject *_wrap_Vector_int_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< int > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_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< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = ((std::vector< int > const *)arg1)->get_allocator();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector_int__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< int > *result = 0 ;
  
  (void)self;
  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< int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< int >::size_type >(val1);
  {
    try {
      result = (std::vector< int > *)new std::vector< int >(SWIG_STD_MOVE(arg1));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


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


SWIGINTERN PyObject *_wrap_Vector_int_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::iterator arg2 ;
  std::vector< int >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< int >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< 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< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< 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< 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< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< 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< int >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_int_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< 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) {
    PyObject *retobj = _wrap_Vector_int_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Vector_int_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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< int >::erase(std::vector< int >::iterator)\n"
    "    std::vector< int >::erase(std::vector< int >::iterator,std::vector< int >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Vector_int__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int >::size_type arg1 ;
  std::vector< int >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< int >::value_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  std::vector< int > *result = 0 ;
  
  (void)self;
  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< int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< int >::size_type >(val1);
  ecode2 = SWIG_AsVal_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< int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (std::vector< int > *)new std::vector< int >(SWIG_STD_MOVE(arg1),(std::vector< int >::value_type const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_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) {
    PyObject *retobj = _wrap_new_Vector_int__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_Vector_int__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Vector_int__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Vector_int__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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< int >::vector()\n"
    "    std::vector< int >::vector(std::vector< int > const &)\n"
    "    std::vector< int >::vector(std::vector< int >::size_type)\n"
    "    std::vector< int >::vector(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_int_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< int >::value_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_int_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< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_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< int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      (arg1)->push_back((std::vector< 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_front" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->front();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(*result));
  (void)swig::container_owner<swig::traits<std::vector< int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_Vector_int_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::size_type arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  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_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_assign" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< 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< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  ecode3 = SWIG_AsVal_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< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::size_type arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< 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< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  ecode3 = SWIG_AsVal_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< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< 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) {
    PyObject *retobj = _wrap_Vector_int_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Vector_int_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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< int >::resize(std::vector< int >::size_type)\n"
    "    std::vector< int >::resize(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_Vector_int_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::iterator arg2 ;
  std::vector< int >::size_type arg3 ;
  std::vector< 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< int >::value_type temp4 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< 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< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< 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< 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< int >::size_type""'");
  } 
  arg3 = static_cast< std::vector< int >::size_type >(val3);
  ecode4 = SWIG_AsVal_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< int >::value_type""'");
  } 
  temp4 = static_cast< std::vector< int >::value_type >(val4);
  arg4 = &temp4;
  {
    try {
      std_vector_Sl_int_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(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) {
    PyObject *retobj = _wrap_Vector_int_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Vector_int_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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< int >::insert(std::vector< int >::iterator,std::vector< int >::value_type const &)\n"
    "    std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_Vector_int_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = ((std::vector< 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_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< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< 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 = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 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 ;
  
  (void)self;
  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_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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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_NullReferenceError, "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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_Vector_string___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Vector_string___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 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] ;
  
  (void)self;
  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_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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) 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_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) 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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) 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 = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Vector_string___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Vector_string___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_string___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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,SWIG_STD_MOVE(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));
  (void)swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  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 = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Vector_string___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Vector_string___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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__(SWIGPY_SLICEOBJECT *)\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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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_NullReferenceError, "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,SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_Vector_string___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Vector_string___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Vector_string___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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__(SWIGPY_SLICEOBJECT *,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *)\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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string > *result = 0 ;
  
  (void)self;
  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_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector_string__SWIG_1(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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_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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::string > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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(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 *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 ;
  
  (void)self;
  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 >(SWIG_STD_MOVE(arg1));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 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;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 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;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_Vector_string_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Vector_string_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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 >(SWIG_STD_MOVE(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_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) {
    PyObject *retobj = _wrap_new_Vector_string__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_Vector_string__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Vector_string__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Vector_string__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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));
  (void)swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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));
  (void)swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 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] ;
  
  (void)self;
  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_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_NullReferenceError, "invalid null reference " "in method '" "Vector_string_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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_NullReferenceError, "invalid null reference " "in method '" "Vector_string_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_Vector_string_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Vector_string_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 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;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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_NullReferenceError, "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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_Vector_string_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Vector_string_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_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 = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__string_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

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

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


SWIGINTERN PyObject *Swig_var__static_Set_end__get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&gum::_static_Set_end_), SWIGTYPE_p_gum__SetIteratorT_int_t,  0 );
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var__static_Set_end_safe__get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&gum::_static_Set_end_safe_), SWIGTYPE_p_gum__SetIteratorSafeT_int_t,  0 );
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var__Set_end__get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(gum::_Set_end_), SWIGTYPE_p_void,  0 );
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var__Set_end_safe__get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(gum::_Set_end_safe_), SWIGTYPE_p_void,  0 );
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_GumException__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::Exception *result = 0 ;
  
  (void)self;
  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""'"); 
    }
    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""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::Exception *)new gum::Exception(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::Exception *result = 0 ;
  
  (void)self;
  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""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::Exception *)new gum::Exception(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::Exception *result = 0 ;
  
  (void)self;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_GumException__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__Exception, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_GumException__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_GumException__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_GumException__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,std::string)\n"
    "    gum::Exception::Exception(std::string)\n"
    "    gum::Exception::Exception()\n"
    "    gum::Exception::Exception(gum::Exception const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GumException(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Exception *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Exception *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  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 = (char *)((gum::Exception const *)arg1)->what();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GumException_errorContent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Exception *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Exception *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Exception *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 = NULL;
  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 *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;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_NullReferenceError, "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_FatalError__SWIG_0(PyObject *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::FatalError *result = 0 ;
  
  (void)self;
  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_FatalError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FatalError" "', 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_FatalError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FatalError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::FatalError *)new gum::FatalError((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FatalError, 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_FatalError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::FatalError *result = 0 ;
  
  (void)self;
  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_FatalError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FatalError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::FatalError *)new gum::FatalError((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FatalError, 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_FatalError__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__FatalError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_FatalError__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_FatalError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_FatalError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::FatalError::FatalError(std::string const &)\n"
    "    gum::FatalError::FatalError(gum::FatalError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FatalError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::FatalError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::NotImplementedYet *result = 0 ;
  
  (void)self;
  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_NotImplementedYet" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NotImplementedYet" "', 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_NotImplementedYet" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NotImplementedYet" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::NotImplementedYet *)new gum::NotImplementedYet((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NotImplementedYet, 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_NotImplementedYet__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::NotImplementedYet *result = 0 ;
  
  (void)self;
  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_NotImplementedYet" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NotImplementedYet" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::NotImplementedYet *)new gum::NotImplementedYet((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NotImplementedYet, 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_NotImplementedYet__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__NotImplementedYet, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_NotImplementedYet__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_NotImplementedYet__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_NotImplementedYet__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::NotImplementedYet::NotImplementedYet(std::string const &)\n"
    "    gum::NotImplementedYet::NotImplementedYet(gum::NotImplementedYet const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NotImplementedYet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NotImplementedYet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_IteratorError__SWIG_0(PyObject *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::IteratorError *result = 0 ;
  
  (void)self;
  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_IteratorError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IteratorError" "', 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_IteratorError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IteratorError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::IteratorError *)new gum::IteratorError((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IteratorError, 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_IteratorError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::IteratorError *result = 0 ;
  
  (void)self;
  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_IteratorError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IteratorError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::IteratorError *)new gum::IteratorError((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IteratorError, 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_IteratorError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IteratorError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::IteratorError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__IteratorError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IteratorError" "', argument " "1"" of type '" "gum::IteratorError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IteratorError" "', argument " "1"" of type '" "gum::IteratorError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::IteratorError * >(argp1);
  {
    try {
      result = (gum::IteratorError *)new gum::IteratorError((gum::IteratorError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IteratorError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IteratorError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IteratorError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__IteratorError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_IteratorError__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_IteratorError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_IteratorError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IteratorError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::IteratorError::IteratorError(std::string const &,std::string const &)\n"
    "    gum::IteratorError::IteratorError(std::string const &)\n"
    "    gum::IteratorError::IteratorError(gum::IteratorError const &)\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_UndefinedIteratorValue__SWIG_0(PyObject *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::UndefinedIteratorValue *result = 0 ;
  
  (void)self;
  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_UndefinedIteratorValue" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UndefinedIteratorValue" "', 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_UndefinedIteratorValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UndefinedIteratorValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::UndefinedIteratorValue *)new gum::UndefinedIteratorValue((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedIteratorValue, 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_UndefinedIteratorValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::UndefinedIteratorValue *result = 0 ;
  
  (void)self;
  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_UndefinedIteratorValue" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UndefinedIteratorValue" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::UndefinedIteratorValue *)new gum::UndefinedIteratorValue((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedIteratorValue, 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_UndefinedIteratorValue__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UndefinedIteratorValue, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_UndefinedIteratorValue__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_UndefinedIteratorValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_UndefinedIteratorValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::UndefinedIteratorValue::UndefinedIteratorValue(std::string const &)\n"
    "    gum::UndefinedIteratorValue::UndefinedIteratorValue(gum::UndefinedIteratorValue const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UndefinedIteratorValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndefinedIteratorValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::UndefinedIteratorKey *result = 0 ;
  
  (void)self;
  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_UndefinedIteratorKey" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UndefinedIteratorKey" "', 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_UndefinedIteratorKey" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UndefinedIteratorKey" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::UndefinedIteratorKey *)new gum::UndefinedIteratorKey((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedIteratorKey, 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_UndefinedIteratorKey__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::UndefinedIteratorKey *result = 0 ;
  
  (void)self;
  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_UndefinedIteratorKey" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UndefinedIteratorKey" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::UndefinedIteratorKey *)new gum::UndefinedIteratorKey((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedIteratorKey, 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_UndefinedIteratorKey__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UndefinedIteratorKey, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_UndefinedIteratorKey__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_UndefinedIteratorKey__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_UndefinedIteratorKey__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::UndefinedIteratorKey::UndefinedIteratorKey(std::string const &)\n"
    "    gum::UndefinedIteratorKey::UndefinedIteratorKey(gum::UndefinedIteratorKey const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UndefinedIteratorKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndefinedIteratorKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::NullElement *result = 0 ;
  
  (void)self;
  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_NullElement" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NullElement" "', 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_NullElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NullElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::NullElement *)new gum::NullElement((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NullElement, 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_NullElement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::NullElement *result = 0 ;
  
  (void)self;
  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_NullElement" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NullElement" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::NullElement *)new gum::NullElement((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NullElement, 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_NullElement__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__NullElement, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_NullElement__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_NullElement__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_NullElement__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::NullElement::NullElement(std::string const &)\n"
    "    gum::NullElement::NullElement(gum::NullElement const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NullElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NullElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::UndefinedElement *result = 0 ;
  
  (void)self;
  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_UndefinedElement" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UndefinedElement" "', 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_UndefinedElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UndefinedElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::UndefinedElement *)new gum::UndefinedElement((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedElement, 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_UndefinedElement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::UndefinedElement *result = 0 ;
  
  (void)self;
  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_UndefinedElement" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UndefinedElement" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::UndefinedElement *)new gum::UndefinedElement((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedElement, 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_UndefinedElement__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UndefinedElement, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_UndefinedElement__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_UndefinedElement__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_UndefinedElement__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::UndefinedElement::UndefinedElement(std::string const &)\n"
    "    gum::UndefinedElement::UndefinedElement(gum::UndefinedElement const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UndefinedElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndefinedElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::SizeError *result = 0 ;
  
  (void)self;
  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_SizeError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SizeError" "', 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_SizeError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SizeError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::SizeError *)new gum::SizeError((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SizeError, 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_SizeError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::SizeError *result = 0 ;
  
  (void)self;
  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_SizeError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SizeError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::SizeError *)new gum::SizeError((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SizeError, 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_SizeError__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__SizeError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_SizeError__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_SizeError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_SizeError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::SizeError::SizeError(std::string const &)\n"
    "    gum::SizeError::SizeError(gum::SizeError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SizeError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::SizeError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_ArgumentError__SWIG_0(PyObject *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::ArgumentError *result = 0 ;
  
  (void)self;
  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_ArgumentError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ArgumentError" "', 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_ArgumentError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ArgumentError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::ArgumentError *)new gum::ArgumentError((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ArgumentError, 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_ArgumentError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::ArgumentError *result = 0 ;
  
  (void)self;
  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_ArgumentError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ArgumentError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::ArgumentError *)new gum::ArgumentError((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ArgumentError, 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_ArgumentError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ArgumentError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::ArgumentError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__ArgumentError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArgumentError" "', argument " "1"" of type '" "gum::ArgumentError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ArgumentError" "', argument " "1"" of type '" "gum::ArgumentError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::ArgumentError * >(argp1);
  {
    try {
      result = (gum::ArgumentError *)new gum::ArgumentError((gum::ArgumentError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ArgumentError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArgumentError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ArgumentError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__ArgumentError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_ArgumentError__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_ArgumentError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_ArgumentError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ArgumentError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ArgumentError::ArgumentError(std::string const &,std::string const &)\n"
    "    gum::ArgumentError::ArgumentError(std::string const &)\n"
    "    gum::ArgumentError::ArgumentError(gum::ArgumentError const &)\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_InvalidArgumentsNumber__SWIG_0(PyObject *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::InvalidArgumentsNumber *result = 0 ;
  
  (void)self;
  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_InvalidArgumentsNumber" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidArgumentsNumber" "', 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_InvalidArgumentsNumber" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidArgumentsNumber" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::InvalidArgumentsNumber *)new gum::InvalidArgumentsNumber((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArgumentsNumber, 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_InvalidArgumentsNumber__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::InvalidArgumentsNumber *result = 0 ;
  
  (void)self;
  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_InvalidArgumentsNumber" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidArgumentsNumber" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::InvalidArgumentsNumber *)new gum::InvalidArgumentsNumber((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArgumentsNumber, 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_InvalidArgumentsNumber__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InvalidArgumentsNumber, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_InvalidArgumentsNumber__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_InvalidArgumentsNumber__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_InvalidArgumentsNumber__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::InvalidArgumentsNumber::InvalidArgumentsNumber(std::string const &)\n"
    "    gum::InvalidArgumentsNumber::InvalidArgumentsNumber(gum::InvalidArgumentsNumber const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidArgumentsNumber(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InvalidArgumentsNumber *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::InvalidArgument *result = 0 ;
  
  (void)self;
  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_InvalidArgument" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidArgument" "', 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_InvalidArgument" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidArgument" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::InvalidArgument *)new gum::InvalidArgument((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArgument, 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_InvalidArgument__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::InvalidArgument *result = 0 ;
  
  (void)self;
  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_InvalidArgument" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidArgument" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::InvalidArgument *)new gum::InvalidArgument((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArgument, 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_InvalidArgument__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InvalidArgument, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_InvalidArgument__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_InvalidArgument__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_InvalidArgument__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::InvalidArgument::InvalidArgument(std::string const &)\n"
    "    gum::InvalidArgument::InvalidArgument(gum::InvalidArgument const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidArgument(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InvalidArgument *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::IOError *result = 0 ;
  
  (void)self;
  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_IOError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IOError" "', 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_IOError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IOError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::IOError *)new gum::IOError((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IOError, 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_IOError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::IOError *result = 0 ;
  
  (void)self;
  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_IOError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IOError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::IOError *)new gum::IOError((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IOError, 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_IOError__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__IOError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_IOError__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_IOError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_IOError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::IOError::IOError(std::string const &)\n"
    "    gum::IOError::IOError(gum::IOError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IOError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IOError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::FormatNotFound *result = 0 ;
  
  (void)self;
  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_FormatNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FormatNotFound" "', 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_FormatNotFound" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FormatNotFound" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::FormatNotFound *)new gum::FormatNotFound((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FormatNotFound, 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_FormatNotFound__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::FormatNotFound *result = 0 ;
  
  (void)self;
  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_FormatNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FormatNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::FormatNotFound *)new gum::FormatNotFound((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FormatNotFound, 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_FormatNotFound__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__FormatNotFound, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_FormatNotFound__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_FormatNotFound__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_FormatNotFound__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::FormatNotFound::FormatNotFound(std::string const &)\n"
    "    gum::FormatNotFound::FormatNotFound(gum::FormatNotFound const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FormatNotFound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::FormatNotFound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::OperationNotAllowed *result = 0 ;
  
  (void)self;
  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_OperationNotAllowed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_OperationNotAllowed" "', 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_OperationNotAllowed" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_OperationNotAllowed" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::OperationNotAllowed *)new gum::OperationNotAllowed((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OperationNotAllowed, 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_OperationNotAllowed__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::OperationNotAllowed *result = 0 ;
  
  (void)self;
  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_OperationNotAllowed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_OperationNotAllowed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::OperationNotAllowed *)new gum::OperationNotAllowed((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OperationNotAllowed, 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_OperationNotAllowed__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__OperationNotAllowed, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_OperationNotAllowed__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_OperationNotAllowed__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_OperationNotAllowed__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::OperationNotAllowed::OperationNotAllowed(std::string const &)\n"
    "    gum::OperationNotAllowed::OperationNotAllowed(gum::OperationNotAllowed const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OperationNotAllowed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::OperationNotAllowed *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::NotFound *result = 0 ;
  
  (void)self;
  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_NotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NotFound" "', 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_NotFound" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NotFound" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::NotFound *)new gum::NotFound((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NotFound, 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_NotFound__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::NotFound *result = 0 ;
  
  (void)self;
  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_NotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::NotFound *)new gum::NotFound((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NotFound, 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_NotFound__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__NotFound, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_NotFound__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_NotFound__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_NotFound__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::NotFound::NotFound(std::string const &)\n"
    "    gum::NotFound::NotFound(gum::NotFound const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NotFound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NotFound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_OutOfBounds__SWIG_0(PyObject *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::OutOfBounds *result = 0 ;
  
  (void)self;
  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_OutOfBounds" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_OutOfBounds" "', 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_OutOfBounds" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_OutOfBounds" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::OutOfBounds *)new gum::OutOfBounds((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OutOfBounds, 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_OutOfBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::OutOfBounds *result = 0 ;
  
  (void)self;
  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_OutOfBounds" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_OutOfBounds" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::OutOfBounds *)new gum::OutOfBounds((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OutOfBounds, 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_OutOfBounds__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__OutOfBounds, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_OutOfBounds__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_OutOfBounds__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_OutOfBounds__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::OutOfBounds::OutOfBounds(std::string const &)\n"
    "    gum::OutOfBounds::OutOfBounds(gum::OutOfBounds const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OutOfBounds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::OutOfBounds *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_DuplicateElement__SWIG_0(PyObject *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::DuplicateElement *result = 0 ;
  
  (void)self;
  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_DuplicateElement" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DuplicateElement" "', 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_DuplicateElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DuplicateElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DuplicateElement *)new gum::DuplicateElement((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DuplicateElement, 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_DuplicateElement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::DuplicateElement *result = 0 ;
  
  (void)self;
  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_DuplicateElement" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DuplicateElement" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::DuplicateElement *)new gum::DuplicateElement((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DuplicateElement, 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_DuplicateElement__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DuplicateElement, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_DuplicateElement__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DuplicateElement__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DuplicateElement__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::DuplicateElement::DuplicateElement(std::string const &)\n"
    "    gum::DuplicateElement::DuplicateElement(gum::DuplicateElement const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DuplicateElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DuplicateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::DuplicateLabel *result = 0 ;
  
  (void)self;
  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_DuplicateLabel" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DuplicateLabel" "', 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_DuplicateLabel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DuplicateLabel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DuplicateLabel *)new gum::DuplicateLabel((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DuplicateLabel, 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_DuplicateLabel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::DuplicateLabel *result = 0 ;
  
  (void)self;
  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_DuplicateLabel" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DuplicateLabel" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::DuplicateLabel *)new gum::DuplicateLabel((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DuplicateLabel, 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_DuplicateLabel__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DuplicateLabel, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_DuplicateLabel__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DuplicateLabel__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DuplicateLabel__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::DuplicateLabel::DuplicateLabel(std::string const &)\n"
    "    gum::DuplicateLabel::DuplicateLabel(gum::DuplicateLabel const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DuplicateLabel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DuplicateLabel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::GraphError *result = 0 ;
  
  (void)self;
  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_GraphError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_GraphError" "', 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_GraphError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_GraphError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::GraphError *)new gum::GraphError((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__GraphError, 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_GraphError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::GraphError *result = 0 ;
  
  (void)self;
  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_GraphError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_GraphError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::GraphError *)new gum::GraphError((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__GraphError, 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_GraphError__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__GraphError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_GraphError__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_GraphError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_GraphError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::GraphError::GraphError(std::string const &)\n"
    "    gum::GraphError::GraphError(gum::GraphError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GraphError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::NoNeighbour *result = 0 ;
  
  (void)self;
  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_NoNeighbour" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NoNeighbour" "', 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_NoNeighbour" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NoNeighbour" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::NoNeighbour *)new gum::NoNeighbour((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoNeighbour, 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_NoNeighbour__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::NoNeighbour *result = 0 ;
  
  (void)self;
  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_NoNeighbour" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NoNeighbour" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::NoNeighbour *)new gum::NoNeighbour((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoNeighbour, 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_NoNeighbour__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__NoNeighbour, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_NoNeighbour__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_NoNeighbour__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_NoNeighbour__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::NoNeighbour::NoNeighbour(std::string const &)\n"
    "    gum::NoNeighbour::NoNeighbour(gum::NoNeighbour const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoNeighbour(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NoNeighbour *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::NoParent *result = 0 ;
  
  (void)self;
  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_NoParent" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NoParent" "', 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_NoParent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NoParent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::NoParent *)new gum::NoParent((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoParent, 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_NoParent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::NoParent *result = 0 ;
  
  (void)self;
  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_NoParent" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NoParent" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::NoParent *)new gum::NoParent((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoParent, 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_NoParent__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__NoParent, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_NoParent__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_NoParent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_NoParent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::NoParent::NoParent(std::string const &)\n"
    "    gum::NoParent::NoParent(gum::NoParent const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoParent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NoParent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::NoChild *result = 0 ;
  
  (void)self;
  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_NoChild" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NoChild" "', 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_NoChild" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NoChild" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::NoChild *)new gum::NoChild((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoChild, 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_NoChild__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::NoChild *result = 0 ;
  
  (void)self;
  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_NoChild" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NoChild" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::NoChild *)new gum::NoChild((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoChild, 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_NoChild__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__NoChild, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_NoChild__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_NoChild__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_NoChild__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::NoChild::NoChild(std::string const &)\n"
    "    gum::NoChild::NoChild(gum::NoChild const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NoChild *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::InvalidEdge *result = 0 ;
  
  (void)self;
  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_InvalidEdge" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidEdge" "', 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_InvalidEdge" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidEdge" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::InvalidEdge *)new gum::InvalidEdge((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidEdge, 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_InvalidEdge__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::InvalidEdge *result = 0 ;
  
  (void)self;
  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_InvalidEdge" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidEdge" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::InvalidEdge *)new gum::InvalidEdge((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidEdge, 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_InvalidEdge__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InvalidEdge, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_InvalidEdge__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_InvalidEdge__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_InvalidEdge__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::InvalidEdge::InvalidEdge(std::string const &)\n"
    "    gum::InvalidEdge::InvalidEdge(gum::InvalidEdge const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidEdge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InvalidEdge *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::InvalidArc *result = 0 ;
  
  (void)self;
  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_InvalidArc" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidArc" "', 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_InvalidArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::InvalidArc *)new gum::InvalidArc((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArc, 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_InvalidArc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::InvalidArc *result = 0 ;
  
  (void)self;
  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_InvalidArc" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidArc" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::InvalidArc *)new gum::InvalidArc((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArc, 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_InvalidArc__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InvalidArc, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_InvalidArc__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_InvalidArc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_InvalidArc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::InvalidArc::InvalidArc(std::string const &)\n"
    "    gum::InvalidArc::InvalidArc(gum::InvalidArc const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidArc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InvalidArc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::InvalidNode *result = 0 ;
  
  (void)self;
  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_InvalidNode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidNode" "', 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_InvalidNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::InvalidNode *)new gum::InvalidNode((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidNode, 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_InvalidNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::InvalidNode *result = 0 ;
  
  (void)self;
  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_InvalidNode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidNode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::InvalidNode *)new gum::InvalidNode((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidNode, 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_InvalidNode__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InvalidNode, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_InvalidNode__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_InvalidNode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_InvalidNode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::InvalidNode::InvalidNode(std::string const &)\n"
    "    gum::InvalidNode::InvalidNode(gum::InvalidNode const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InvalidNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_DefaultInLabel__SWIG_0(PyObject *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::DefaultInLabel *result = 0 ;
  
  (void)self;
  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_DefaultInLabel" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DefaultInLabel" "', 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_DefaultInLabel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DefaultInLabel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DefaultInLabel *)new gum::DefaultInLabel((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DefaultInLabel, 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_DefaultInLabel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::DefaultInLabel *result = 0 ;
  
  (void)self;
  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_DefaultInLabel" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DefaultInLabel" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::DefaultInLabel *)new gum::DefaultInLabel((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DefaultInLabel, 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_DefaultInLabel__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DefaultInLabel, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_DefaultInLabel__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DefaultInLabel__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DefaultInLabel__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::DefaultInLabel::DefaultInLabel(std::string const &)\n"
    "    gum::DefaultInLabel::DefaultInLabel(gum::DefaultInLabel const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DefaultInLabel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DefaultInLabel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::InvalidDirectedCycle *result = 0 ;
  
  (void)self;
  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_InvalidDirectedCycle" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidDirectedCycle" "', 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_InvalidDirectedCycle" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidDirectedCycle" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::InvalidDirectedCycle *)new gum::InvalidDirectedCycle((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidDirectedCycle, 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_InvalidDirectedCycle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::InvalidDirectedCycle *result = 0 ;
  
  (void)self;
  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_InvalidDirectedCycle" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidDirectedCycle" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::InvalidDirectedCycle *)new gum::InvalidDirectedCycle((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidDirectedCycle, 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_InvalidDirectedCycle__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InvalidDirectedCycle, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_InvalidDirectedCycle__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_InvalidDirectedCycle__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_InvalidDirectedCycle__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::InvalidDirectedCycle::InvalidDirectedCycle(std::string const &)\n"
    "    gum::InvalidDirectedCycle::InvalidDirectedCycle(gum::InvalidDirectedCycle const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidDirectedCycle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InvalidDirectedCycle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_InvalidPartiallyDirectedCycle__SWIG_0(PyObject *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::InvalidPartiallyDirectedCycle *result = 0 ;
  
  (void)self;
  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_InvalidPartiallyDirectedCycle" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidPartiallyDirectedCycle" "', 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_InvalidPartiallyDirectedCycle" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidPartiallyDirectedCycle" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::InvalidPartiallyDirectedCycle *)new gum::InvalidPartiallyDirectedCycle((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidPartiallyDirectedCycle, 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_InvalidPartiallyDirectedCycle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::InvalidPartiallyDirectedCycle *result = 0 ;
  
  (void)self;
  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_InvalidPartiallyDirectedCycle" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidPartiallyDirectedCycle" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::InvalidPartiallyDirectedCycle *)new gum::InvalidPartiallyDirectedCycle((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidPartiallyDirectedCycle, 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_InvalidPartiallyDirectedCycle__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InvalidPartiallyDirectedCycle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::InvalidPartiallyDirectedCycle *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__InvalidPartiallyDirectedCycle,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvalidPartiallyDirectedCycle" "', argument " "1"" of type '" "gum::InvalidPartiallyDirectedCycle const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InvalidPartiallyDirectedCycle" "', argument " "1"" of type '" "gum::InvalidPartiallyDirectedCycle const &""'"); 
  }
  arg1 = reinterpret_cast< gum::InvalidPartiallyDirectedCycle * >(argp1);
  {
    try {
      result = (gum::InvalidPartiallyDirectedCycle *)new gum::InvalidPartiallyDirectedCycle((gum::InvalidPartiallyDirectedCycle const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidPartiallyDirectedCycle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidPartiallyDirectedCycle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvalidPartiallyDirectedCycle", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InvalidPartiallyDirectedCycle, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_InvalidPartiallyDirectedCycle__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_InvalidPartiallyDirectedCycle__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_InvalidPartiallyDirectedCycle__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvalidPartiallyDirectedCycle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InvalidPartiallyDirectedCycle::InvalidPartiallyDirectedCycle(std::string const &,std::string const &)\n"
    "    gum::InvalidPartiallyDirectedCycle::InvalidPartiallyDirectedCycle(std::string const &)\n"
    "    gum::InvalidPartiallyDirectedCycle::InvalidPartiallyDirectedCycle(gum::InvalidPartiallyDirectedCycle const &)\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_CPTError__SWIG_0(PyObject *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::CPTError *result = 0 ;
  
  (void)self;
  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_CPTError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CPTError" "', 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_CPTError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CPTError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::CPTError *)new gum::CPTError((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CPTError, 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_CPTError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::CPTError *result = 0 ;
  
  (void)self;
  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_CPTError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CPTError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::CPTError *)new gum::CPTError((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CPTError, 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_CPTError__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__CPTError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_CPTError__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_CPTError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_CPTError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::CPTError::CPTError(std::string const &)\n"
    "    gum::CPTError::CPTError(gum::CPTError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CPTError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CPTError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_ScheduleMultiDimError__SWIG_0(PyObject *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::ScheduleMultiDimError *result = 0 ;
  
  (void)self;
  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_ScheduleMultiDimError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ScheduleMultiDimError" "', 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_ScheduleMultiDimError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ScheduleMultiDimError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::ScheduleMultiDimError *)new gum::ScheduleMultiDimError((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ScheduleMultiDimError, 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_ScheduleMultiDimError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::ScheduleMultiDimError *result = 0 ;
  
  (void)self;
  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_ScheduleMultiDimError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ScheduleMultiDimError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::ScheduleMultiDimError *)new gum::ScheduleMultiDimError((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ScheduleMultiDimError, 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_ScheduleMultiDimError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ScheduleMultiDimError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::ScheduleMultiDimError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__ScheduleMultiDimError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScheduleMultiDimError" "', argument " "1"" of type '" "gum::ScheduleMultiDimError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ScheduleMultiDimError" "', argument " "1"" of type '" "gum::ScheduleMultiDimError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::ScheduleMultiDimError * >(argp1);
  {
    try {
      result = (gum::ScheduleMultiDimError *)new gum::ScheduleMultiDimError((gum::ScheduleMultiDimError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ScheduleMultiDimError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScheduleMultiDimError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScheduleMultiDimError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__ScheduleMultiDimError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_ScheduleMultiDimError__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_ScheduleMultiDimError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_ScheduleMultiDimError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScheduleMultiDimError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ScheduleMultiDimError::ScheduleMultiDimError(std::string const &,std::string const &)\n"
    "    gum::ScheduleMultiDimError::ScheduleMultiDimError(std::string const &)\n"
    "    gum::ScheduleMultiDimError::ScheduleMultiDimError(gum::ScheduleMultiDimError const &)\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_AbstractScheduleMultiDim__SWIG_0(PyObject *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::AbstractScheduleMultiDim *result = 0 ;
  
  (void)self;
  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_AbstractScheduleMultiDim" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_AbstractScheduleMultiDim" "', 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_AbstractScheduleMultiDim" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_AbstractScheduleMultiDim" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::AbstractScheduleMultiDim *)new gum::AbstractScheduleMultiDim((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__AbstractScheduleMultiDim, 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_AbstractScheduleMultiDim__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::AbstractScheduleMultiDim *result = 0 ;
  
  (void)self;
  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_AbstractScheduleMultiDim" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_AbstractScheduleMultiDim" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::AbstractScheduleMultiDim *)new gum::AbstractScheduleMultiDim((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__AbstractScheduleMultiDim, 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_AbstractScheduleMultiDim__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::AbstractScheduleMultiDim *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::AbstractScheduleMultiDim *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__AbstractScheduleMultiDim,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AbstractScheduleMultiDim" "', argument " "1"" of type '" "gum::AbstractScheduleMultiDim const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_AbstractScheduleMultiDim" "', argument " "1"" of type '" "gum::AbstractScheduleMultiDim const &""'"); 
  }
  arg1 = reinterpret_cast< gum::AbstractScheduleMultiDim * >(argp1);
  {
    try {
      result = (gum::AbstractScheduleMultiDim *)new gum::AbstractScheduleMultiDim((gum::AbstractScheduleMultiDim const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__AbstractScheduleMultiDim, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AbstractScheduleMultiDim(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AbstractScheduleMultiDim", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__AbstractScheduleMultiDim, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_AbstractScheduleMultiDim__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_AbstractScheduleMultiDim__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_AbstractScheduleMultiDim__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AbstractScheduleMultiDim'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::AbstractScheduleMultiDim::AbstractScheduleMultiDim(std::string const &,std::string const &)\n"
    "    gum::AbstractScheduleMultiDim::AbstractScheduleMultiDim(std::string const &)\n"
    "    gum::AbstractScheduleMultiDim::AbstractScheduleMultiDim(gum::AbstractScheduleMultiDim const &)\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_UnknownScheduleMultiDim__SWIG_0(PyObject *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::UnknownScheduleMultiDim *result = 0 ;
  
  (void)self;
  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_UnknownScheduleMultiDim" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnknownScheduleMultiDim" "', 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_UnknownScheduleMultiDim" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnknownScheduleMultiDim" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::UnknownScheduleMultiDim *)new gum::UnknownScheduleMultiDim((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnknownScheduleMultiDim, 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_UnknownScheduleMultiDim__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::UnknownScheduleMultiDim *result = 0 ;
  
  (void)self;
  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_UnknownScheduleMultiDim" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnknownScheduleMultiDim" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::UnknownScheduleMultiDim *)new gum::UnknownScheduleMultiDim((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnknownScheduleMultiDim, 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_UnknownScheduleMultiDim__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UnknownScheduleMultiDim *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::UnknownScheduleMultiDim *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__UnknownScheduleMultiDim,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnknownScheduleMultiDim" "', argument " "1"" of type '" "gum::UnknownScheduleMultiDim const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnknownScheduleMultiDim" "', argument " "1"" of type '" "gum::UnknownScheduleMultiDim const &""'"); 
  }
  arg1 = reinterpret_cast< gum::UnknownScheduleMultiDim * >(argp1);
  {
    try {
      result = (gum::UnknownScheduleMultiDim *)new gum::UnknownScheduleMultiDim((gum::UnknownScheduleMultiDim const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnknownScheduleMultiDim, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnknownScheduleMultiDim(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UnknownScheduleMultiDim", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UnknownScheduleMultiDim, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_UnknownScheduleMultiDim__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_UnknownScheduleMultiDim__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_UnknownScheduleMultiDim__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UnknownScheduleMultiDim'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UnknownScheduleMultiDim::UnknownScheduleMultiDim(std::string const &,std::string const &)\n"
    "    gum::UnknownScheduleMultiDim::UnknownScheduleMultiDim(std::string const &)\n"
    "    gum::UnknownScheduleMultiDim::UnknownScheduleMultiDim(gum::UnknownScheduleMultiDim const &)\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_DuplicateScheduleMultiDim__SWIG_0(PyObject *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::DuplicateScheduleMultiDim *result = 0 ;
  
  (void)self;
  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_DuplicateScheduleMultiDim" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DuplicateScheduleMultiDim" "', 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_DuplicateScheduleMultiDim" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DuplicateScheduleMultiDim" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DuplicateScheduleMultiDim *)new gum::DuplicateScheduleMultiDim((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DuplicateScheduleMultiDim, 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_DuplicateScheduleMultiDim__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::DuplicateScheduleMultiDim *result = 0 ;
  
  (void)self;
  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_DuplicateScheduleMultiDim" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DuplicateScheduleMultiDim" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::DuplicateScheduleMultiDim *)new gum::DuplicateScheduleMultiDim((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DuplicateScheduleMultiDim, 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_DuplicateScheduleMultiDim__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DuplicateScheduleMultiDim *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::DuplicateScheduleMultiDim *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__DuplicateScheduleMultiDim,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DuplicateScheduleMultiDim" "', argument " "1"" of type '" "gum::DuplicateScheduleMultiDim const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DuplicateScheduleMultiDim" "', argument " "1"" of type '" "gum::DuplicateScheduleMultiDim const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DuplicateScheduleMultiDim * >(argp1);
  {
    try {
      result = (gum::DuplicateScheduleMultiDim *)new gum::DuplicateScheduleMultiDim((gum::DuplicateScheduleMultiDim const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DuplicateScheduleMultiDim, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplicateScheduleMultiDim(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DuplicateScheduleMultiDim", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DuplicateScheduleMultiDim, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_DuplicateScheduleMultiDim__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DuplicateScheduleMultiDim__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DuplicateScheduleMultiDim__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DuplicateScheduleMultiDim'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DuplicateScheduleMultiDim::DuplicateScheduleMultiDim(std::string const &,std::string const &)\n"
    "    gum::DuplicateScheduleMultiDim::DuplicateScheduleMultiDim(std::string const &)\n"
    "    gum::DuplicateScheduleMultiDim::DuplicateScheduleMultiDim(gum::DuplicateScheduleMultiDim const &)\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_ScheduleOperationError__SWIG_0(PyObject *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::ScheduleOperationError *result = 0 ;
  
  (void)self;
  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_ScheduleOperationError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ScheduleOperationError" "', 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_ScheduleOperationError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ScheduleOperationError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::ScheduleOperationError *)new gum::ScheduleOperationError((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ScheduleOperationError, 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_ScheduleOperationError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::ScheduleOperationError *result = 0 ;
  
  (void)self;
  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_ScheduleOperationError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ScheduleOperationError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::ScheduleOperationError *)new gum::ScheduleOperationError((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ScheduleOperationError, 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_ScheduleOperationError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ScheduleOperationError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::ScheduleOperationError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__ScheduleOperationError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScheduleOperationError" "', argument " "1"" of type '" "gum::ScheduleOperationError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ScheduleOperationError" "', argument " "1"" of type '" "gum::ScheduleOperationError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::ScheduleOperationError * >(argp1);
  {
    try {
      result = (gum::ScheduleOperationError *)new gum::ScheduleOperationError((gum::ScheduleOperationError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ScheduleOperationError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScheduleOperationError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScheduleOperationError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__ScheduleOperationError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_ScheduleOperationError__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_ScheduleOperationError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_ScheduleOperationError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScheduleOperationError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ScheduleOperationError::ScheduleOperationError(std::string const &,std::string const &)\n"
    "    gum::ScheduleOperationError::ScheduleOperationError(std::string const &)\n"
    "    gum::ScheduleOperationError::ScheduleOperationError(gum::ScheduleOperationError const &)\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_UnknownScheduleOperation__SWIG_0(PyObject *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::UnknownScheduleOperation *result = 0 ;
  
  (void)self;
  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_UnknownScheduleOperation" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnknownScheduleOperation" "', 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_UnknownScheduleOperation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnknownScheduleOperation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::UnknownScheduleOperation *)new gum::UnknownScheduleOperation((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnknownScheduleOperation, 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_UnknownScheduleOperation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::UnknownScheduleOperation *result = 0 ;
  
  (void)self;
  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_UnknownScheduleOperation" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnknownScheduleOperation" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::UnknownScheduleOperation *)new gum::UnknownScheduleOperation((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnknownScheduleOperation, 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_UnknownScheduleOperation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UnknownScheduleOperation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::UnknownScheduleOperation *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__UnknownScheduleOperation,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnknownScheduleOperation" "', argument " "1"" of type '" "gum::UnknownScheduleOperation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnknownScheduleOperation" "', argument " "1"" of type '" "gum::UnknownScheduleOperation const &""'"); 
  }
  arg1 = reinterpret_cast< gum::UnknownScheduleOperation * >(argp1);
  {
    try {
      result = (gum::UnknownScheduleOperation *)new gum::UnknownScheduleOperation((gum::UnknownScheduleOperation const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnknownScheduleOperation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnknownScheduleOperation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UnknownScheduleOperation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UnknownScheduleOperation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_UnknownScheduleOperation__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_UnknownScheduleOperation__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_UnknownScheduleOperation__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UnknownScheduleOperation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UnknownScheduleOperation::UnknownScheduleOperation(std::string const &,std::string const &)\n"
    "    gum::UnknownScheduleOperation::UnknownScheduleOperation(std::string const &)\n"
    "    gum::UnknownScheduleOperation::UnknownScheduleOperation(gum::UnknownScheduleOperation const &)\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_UnavailableScheduleOperation__SWIG_0(PyObject *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::UnavailableScheduleOperation *result = 0 ;
  
  (void)self;
  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_UnavailableScheduleOperation" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnavailableScheduleOperation" "', 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_UnavailableScheduleOperation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnavailableScheduleOperation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::UnavailableScheduleOperation *)new gum::UnavailableScheduleOperation((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnavailableScheduleOperation, 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_UnavailableScheduleOperation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::UnavailableScheduleOperation *result = 0 ;
  
  (void)self;
  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_UnavailableScheduleOperation" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnavailableScheduleOperation" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::UnavailableScheduleOperation *)new gum::UnavailableScheduleOperation((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnavailableScheduleOperation, 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_UnavailableScheduleOperation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UnavailableScheduleOperation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::UnavailableScheduleOperation *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__UnavailableScheduleOperation,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnavailableScheduleOperation" "', argument " "1"" of type '" "gum::UnavailableScheduleOperation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnavailableScheduleOperation" "', argument " "1"" of type '" "gum::UnavailableScheduleOperation const &""'"); 
  }
  arg1 = reinterpret_cast< gum::UnavailableScheduleOperation * >(argp1);
  {
    try {
      result = (gum::UnavailableScheduleOperation *)new gum::UnavailableScheduleOperation((gum::UnavailableScheduleOperation const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnavailableScheduleOperation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnavailableScheduleOperation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UnavailableScheduleOperation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UnavailableScheduleOperation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_UnavailableScheduleOperation__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_UnavailableScheduleOperation__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_UnavailableScheduleOperation__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UnavailableScheduleOperation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UnavailableScheduleOperation::UnavailableScheduleOperation(std::string const &,std::string const &)\n"
    "    gum::UnavailableScheduleOperation::UnavailableScheduleOperation(std::string const &)\n"
    "    gum::UnavailableScheduleOperation::UnavailableScheduleOperation(gum::UnavailableScheduleOperation const &)\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_UnexecutedScheduleOperation__SWIG_0(PyObject *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::UnexecutedScheduleOperation *result = 0 ;
  
  (void)self;
  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_UnexecutedScheduleOperation" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnexecutedScheduleOperation" "', 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_UnexecutedScheduleOperation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnexecutedScheduleOperation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::UnexecutedScheduleOperation *)new gum::UnexecutedScheduleOperation((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnexecutedScheduleOperation, 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_UnexecutedScheduleOperation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::UnexecutedScheduleOperation *result = 0 ;
  
  (void)self;
  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_UnexecutedScheduleOperation" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnexecutedScheduleOperation" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::UnexecutedScheduleOperation *)new gum::UnexecutedScheduleOperation((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnexecutedScheduleOperation, 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_UnexecutedScheduleOperation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UnexecutedScheduleOperation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::UnexecutedScheduleOperation *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__UnexecutedScheduleOperation,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnexecutedScheduleOperation" "', argument " "1"" of type '" "gum::UnexecutedScheduleOperation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnexecutedScheduleOperation" "', argument " "1"" of type '" "gum::UnexecutedScheduleOperation const &""'"); 
  }
  arg1 = reinterpret_cast< gum::UnexecutedScheduleOperation * >(argp1);
  {
    try {
      result = (gum::UnexecutedScheduleOperation *)new gum::UnexecutedScheduleOperation((gum::UnexecutedScheduleOperation const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnexecutedScheduleOperation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnexecutedScheduleOperation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UnexecutedScheduleOperation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UnexecutedScheduleOperation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_UnexecutedScheduleOperation__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_UnexecutedScheduleOperation__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_UnexecutedScheduleOperation__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UnexecutedScheduleOperation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UnexecutedScheduleOperation::UnexecutedScheduleOperation(std::string const &,std::string const &)\n"
    "    gum::UnexecutedScheduleOperation::UnexecutedScheduleOperation(std::string const &)\n"
    "    gum::UnexecutedScheduleOperation::UnexecutedScheduleOperation(gum::UnexecutedScheduleOperation const &)\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_IncompatibleEvidence__SWIG_0(PyObject *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::IncompatibleEvidence *result = 0 ;
  
  (void)self;
  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_IncompatibleEvidence" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IncompatibleEvidence" "', 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_IncompatibleEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IncompatibleEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::IncompatibleEvidence *)new gum::IncompatibleEvidence((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IncompatibleEvidence, 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_IncompatibleEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::IncompatibleEvidence *result = 0 ;
  
  (void)self;
  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_IncompatibleEvidence" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IncompatibleEvidence" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::IncompatibleEvidence *)new gum::IncompatibleEvidence((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IncompatibleEvidence, 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_IncompatibleEvidence__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__IncompatibleEvidence, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_IncompatibleEvidence__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_IncompatibleEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_IncompatibleEvidence__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::IncompatibleEvidence::IncompatibleEvidence(std::string const &)\n"
    "    gum::IncompatibleEvidence::IncompatibleEvidence(gum::IncompatibleEvidence const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IncompatibleEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IncompatibleEvidence *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::FactoryError *result = 0 ;
  
  (void)self;
  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_FactoryError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FactoryError" "', 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_FactoryError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FactoryError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::FactoryError *)new gum::FactoryError((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FactoryError, 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_FactoryError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::FactoryError *result = 0 ;
  
  (void)self;
  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_FactoryError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FactoryError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::FactoryError *)new gum::FactoryError((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FactoryError, 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_FactoryError__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__FactoryError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_FactoryError__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_FactoryError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_FactoryError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::FactoryError::FactoryError(std::string const &)\n"
    "    gum::FactoryError::FactoryError(gum::FactoryError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FactoryError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::FactoryError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::FactoryInvalidState *result = 0 ;
  
  (void)self;
  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_FactoryInvalidState" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FactoryInvalidState" "', 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_FactoryInvalidState" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FactoryInvalidState" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::FactoryInvalidState *)new gum::FactoryInvalidState((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FactoryInvalidState, 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_FactoryInvalidState__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::FactoryInvalidState *result = 0 ;
  
  (void)self;
  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_FactoryInvalidState" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FactoryInvalidState" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::FactoryInvalidState *)new gum::FactoryInvalidState((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FactoryInvalidState, 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_FactoryInvalidState__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__FactoryInvalidState, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_FactoryInvalidState__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_FactoryInvalidState__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_FactoryInvalidState__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::FactoryInvalidState::FactoryInvalidState(std::string const &)\n"
    "    gum::FactoryInvalidState::FactoryInvalidState(gum::FactoryInvalidState const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FactoryInvalidState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::FactoryInvalidState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_TypeError__SWIG_0(PyObject *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::TypeError *result = 0 ;
  
  (void)self;
  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_TypeError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_TypeError" "', 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_TypeError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_TypeError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::TypeError *)new gum::TypeError((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TypeError, 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_TypeError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::TypeError *result = 0 ;
  
  (void)self;
  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_TypeError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_TypeError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::TypeError *)new gum::TypeError((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TypeError, 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_TypeError__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__TypeError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_TypeError__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_TypeError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_TypeError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::TypeError::TypeError(std::string const &)\n"
    "    gum::TypeError::TypeError(gum::TypeError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TypeError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::TypeError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_WrongClassElement__SWIG_0(PyObject *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::WrongClassElement *result = 0 ;
  
  (void)self;
  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_WrongClassElement" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_WrongClassElement" "', 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_WrongClassElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_WrongClassElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::WrongClassElement *)new gum::WrongClassElement((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__WrongClassElement, 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_WrongClassElement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::WrongClassElement *result = 0 ;
  
  (void)self;
  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_WrongClassElement" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_WrongClassElement" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::WrongClassElement *)new gum::WrongClassElement((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__WrongClassElement, 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_WrongClassElement__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__WrongClassElement, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_WrongClassElement__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_WrongClassElement__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_WrongClassElement__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::WrongClassElement::WrongClassElement(std::string const &)\n"
    "    gum::WrongClassElement::WrongClassElement(gum::WrongClassElement const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_WrongClassElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WrongClassElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_PRMTypeError__SWIG_0(PyObject *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::PRMTypeError *result = 0 ;
  
  (void)self;
  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_PRMTypeError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PRMTypeError" "', 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_PRMTypeError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PRMTypeError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::PRMTypeError *)new gum::PRMTypeError((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PRMTypeError, 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_PRMTypeError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::PRMTypeError *result = 0 ;
  
  (void)self;
  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_PRMTypeError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PRMTypeError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::PRMTypeError *)new gum::PRMTypeError((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PRMTypeError, 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_PRMTypeError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PRMTypeError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::PRMTypeError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__PRMTypeError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PRMTypeError" "', argument " "1"" of type '" "gum::PRMTypeError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PRMTypeError" "', argument " "1"" of type '" "gum::PRMTypeError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::PRMTypeError * >(argp1);
  {
    try {
      result = (gum::PRMTypeError *)new gum::PRMTypeError((gum::PRMTypeError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PRMTypeError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PRMTypeError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PRMTypeError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__PRMTypeError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_PRMTypeError__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_PRMTypeError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_PRMTypeError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PRMTypeError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::PRMTypeError::PRMTypeError(std::string const &,std::string const &)\n"
    "    gum::PRMTypeError::PRMTypeError(std::string const &)\n"
    "    gum::PRMTypeError::PRMTypeError(gum::PRMTypeError const &)\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_LearningError__SWIG_0(PyObject *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::LearningError *result = 0 ;
  
  (void)self;
  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_LearningError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_LearningError" "', 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_LearningError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_LearningError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::LearningError *)new gum::LearningError((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LearningError, 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_LearningError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::LearningError *result = 0 ;
  
  (void)self;
  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_LearningError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_LearningError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::LearningError *)new gum::LearningError((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LearningError, 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_LearningError__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__LearningError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_LearningError__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_LearningError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_LearningError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::LearningError::LearningError(std::string const &)\n"
    "    gum::LearningError::LearningError(gum::LearningError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LearningError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LearningError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_IncompatibleScorePrior__SWIG_0(PyObject *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::IncompatibleScorePrior *result = 0 ;
  
  (void)self;
  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_IncompatibleScorePrior" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IncompatibleScorePrior" "', 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_IncompatibleScorePrior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IncompatibleScorePrior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::IncompatibleScorePrior *)new gum::IncompatibleScorePrior((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IncompatibleScorePrior, 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_IncompatibleScorePrior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::IncompatibleScorePrior *result = 0 ;
  
  (void)self;
  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_IncompatibleScorePrior" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IncompatibleScorePrior" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::IncompatibleScorePrior *)new gum::IncompatibleScorePrior((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IncompatibleScorePrior, 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_IncompatibleScorePrior__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IncompatibleScorePrior *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::IncompatibleScorePrior *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__IncompatibleScorePrior,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IncompatibleScorePrior" "', argument " "1"" of type '" "gum::IncompatibleScorePrior const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IncompatibleScorePrior" "', argument " "1"" of type '" "gum::IncompatibleScorePrior const &""'"); 
  }
  arg1 = reinterpret_cast< gum::IncompatibleScorePrior * >(argp1);
  {
    try {
      result = (gum::IncompatibleScorePrior *)new gum::IncompatibleScorePrior((gum::IncompatibleScorePrior const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IncompatibleScorePrior, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncompatibleScorePrior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IncompatibleScorePrior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__IncompatibleScorePrior, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_IncompatibleScorePrior__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_IncompatibleScorePrior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_IncompatibleScorePrior__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IncompatibleScorePrior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::IncompatibleScorePrior::IncompatibleScorePrior(std::string const &,std::string const &)\n"
    "    gum::IncompatibleScorePrior::IncompatibleScorePrior(std::string const &)\n"
    "    gum::IncompatibleScorePrior::IncompatibleScorePrior(gum::IncompatibleScorePrior const &)\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_PossiblyIncompatibleScorePrior__SWIG_0(PyObject *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::PossiblyIncompatibleScorePrior *result = 0 ;
  
  (void)self;
  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_PossiblyIncompatibleScorePrior" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PossiblyIncompatibleScorePrior" "', 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_PossiblyIncompatibleScorePrior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PossiblyIncompatibleScorePrior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::PossiblyIncompatibleScorePrior *)new gum::PossiblyIncompatibleScorePrior((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PossiblyIncompatibleScorePrior, 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_PossiblyIncompatibleScorePrior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::PossiblyIncompatibleScorePrior *result = 0 ;
  
  (void)self;
  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_PossiblyIncompatibleScorePrior" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PossiblyIncompatibleScorePrior" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::PossiblyIncompatibleScorePrior *)new gum::PossiblyIncompatibleScorePrior((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PossiblyIncompatibleScorePrior, 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_PossiblyIncompatibleScorePrior__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PossiblyIncompatibleScorePrior *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::PossiblyIncompatibleScorePrior *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__PossiblyIncompatibleScorePrior,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PossiblyIncompatibleScorePrior" "', argument " "1"" of type '" "gum::PossiblyIncompatibleScorePrior const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PossiblyIncompatibleScorePrior" "', argument " "1"" of type '" "gum::PossiblyIncompatibleScorePrior const &""'"); 
  }
  arg1 = reinterpret_cast< gum::PossiblyIncompatibleScorePrior * >(argp1);
  {
    try {
      result = (gum::PossiblyIncompatibleScorePrior *)new gum::PossiblyIncompatibleScorePrior((gum::PossiblyIncompatibleScorePrior const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PossiblyIncompatibleScorePrior, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PossiblyIncompatibleScorePrior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PossiblyIncompatibleScorePrior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__PossiblyIncompatibleScorePrior, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_PossiblyIncompatibleScorePrior__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_PossiblyIncompatibleScorePrior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_PossiblyIncompatibleScorePrior__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PossiblyIncompatibleScorePrior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::PossiblyIncompatibleScorePrior::PossiblyIncompatibleScorePrior(std::string const &,std::string const &)\n"
    "    gum::PossiblyIncompatibleScorePrior::PossiblyIncompatibleScorePrior(std::string const &)\n"
    "    gum::PossiblyIncompatibleScorePrior::PossiblyIncompatibleScorePrior(gum::PossiblyIncompatibleScorePrior const &)\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_DatabaseError__SWIG_0(PyObject *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::DatabaseError *result = 0 ;
  
  (void)self;
  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_DatabaseError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DatabaseError" "', 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_DatabaseError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DatabaseError" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DatabaseError *)new gum::DatabaseError((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DatabaseError, 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_DatabaseError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::DatabaseError *result = 0 ;
  
  (void)self;
  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_DatabaseError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DatabaseError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::DatabaseError *)new gum::DatabaseError((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DatabaseError, 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_DatabaseError__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DatabaseError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_DatabaseError__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DatabaseError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DatabaseError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::DatabaseError::DatabaseError(std::string const &)\n"
    "    gum::DatabaseError::DatabaseError(gum::DatabaseError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DatabaseError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DatabaseError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::MissingVariableInDatabase *result = 0 ;
  
  (void)self;
  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_MissingVariableInDatabase" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MissingVariableInDatabase" "', 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_MissingVariableInDatabase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MissingVariableInDatabase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::MissingVariableInDatabase *)new gum::MissingVariableInDatabase((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MissingVariableInDatabase, 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_MissingVariableInDatabase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::MissingVariableInDatabase *result = 0 ;
  
  (void)self;
  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_MissingVariableInDatabase" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MissingVariableInDatabase" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::MissingVariableInDatabase *)new gum::MissingVariableInDatabase((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MissingVariableInDatabase, 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_MissingVariableInDatabase__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__MissingVariableInDatabase, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_MissingVariableInDatabase__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_MissingVariableInDatabase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_MissingVariableInDatabase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::MissingVariableInDatabase::MissingVariableInDatabase(std::string const &)\n"
    "    gum::MissingVariableInDatabase::MissingVariableInDatabase(gum::MissingVariableInDatabase const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MissingVariableInDatabase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MissingVariableInDatabase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::MissingValueInDatabase *result = 0 ;
  
  (void)self;
  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_MissingValueInDatabase" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MissingValueInDatabase" "', 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_MissingValueInDatabase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MissingValueInDatabase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::MissingValueInDatabase *)new gum::MissingValueInDatabase((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MissingValueInDatabase, 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_MissingValueInDatabase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::MissingValueInDatabase *result = 0 ;
  
  (void)self;
  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_MissingValueInDatabase" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MissingValueInDatabase" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::MissingValueInDatabase *)new gum::MissingValueInDatabase((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MissingValueInDatabase, 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_MissingValueInDatabase__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__MissingValueInDatabase, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_MissingValueInDatabase__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_MissingValueInDatabase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_MissingValueInDatabase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::MissingValueInDatabase::MissingValueInDatabase(std::string const &)\n"
    "    gum::MissingValueInDatabase::MissingValueInDatabase(gum::MissingValueInDatabase const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MissingValueInDatabase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MissingValueInDatabase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *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::UnknownLabelInDatabase *result = 0 ;
  
  (void)self;
  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_UnknownLabelInDatabase" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnknownLabelInDatabase" "', 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_UnknownLabelInDatabase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnknownLabelInDatabase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::UnknownLabelInDatabase *)new gum::UnknownLabelInDatabase((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnknownLabelInDatabase, 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_UnknownLabelInDatabase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::UnknownLabelInDatabase *result = 0 ;
  
  (void)self;
  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_UnknownLabelInDatabase" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UnknownLabelInDatabase" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::UnknownLabelInDatabase *)new gum::UnknownLabelInDatabase((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnknownLabelInDatabase, 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_UnknownLabelInDatabase__SWIG_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UnknownLabelInDatabase, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_UnknownLabelInDatabase__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_UnknownLabelInDatabase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_UnknownLabelInDatabase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 const &,std::string const &)\n"
    "    gum::UnknownLabelInDatabase::UnknownLabelInDatabase(std::string const &)\n"
    "    gum::UnknownLabelInDatabase::UnknownLabelInDatabase(gum::UnknownLabelInDatabase const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnknownLabelInDatabase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UnknownLabelInDatabase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string arg2 ;
  gum::Size arg3 ;
  gum::Size arg4 ;
  std::string *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  gum::SyntaxError *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) 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_NullReferenceError, "invalid null reference " "in method '" "new_SyntaxError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = 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_SyntaxError" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  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);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SyntaxError" "', argument " "4"" of type '" "gum::Size""'");
  } 
  arg4 = static_cast< gum::Size >(val4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SyntaxError" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SyntaxError" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (gum::SyntaxError *)new gum::SyntaxError((std::string const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),(std::string const &)*arg5);
    } 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;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SyntaxError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string arg2 ;
  gum::Size arg3 ;
  gum::Size arg4 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  gum::SyntaxError *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "new_SyntaxError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = 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_SyntaxError" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  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);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SyntaxError" "', argument " "4"" of type '" "gum::Size""'");
  } 
  arg4 = static_cast< gum::Size >(val4);
  {
    try {
      result = (gum::SyntaxError *)new gum::SyntaxError((std::string const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(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(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SyntaxError", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    PyObject *retobj = _wrap_new_SyntaxError__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_new_SyntaxError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 &,std::string,gum::Size,gum::Size,std::string const &)\n"
    "    gum::SyntaxError::SyntaxError(std::string const &,std::string,gum::Size,gum::Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SyntaxError_col(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::SyntaxError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::SyntaxError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_SyntaxError_filename(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::SyntaxError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_filename" "', argument " "1"" of type '" "gum::SyntaxError const *""'"); 
  }
  arg1 = reinterpret_cast< gum::SyntaxError * >(argp1);
  {
    try {
      result = ((gum::SyntaxError const *)arg1)->filename();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SyntaxError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::SyntaxError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_setNumberOfThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_isOMP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  (void)self;
  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_dispatchRangeToThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Idx arg1 ;
  gum::Idx arg2 ;
  unsigned int arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SwigValueWrapper< std::vector< std::pair< std::size_t,std::size_t >,std::allocator< std::pair< std::size_t,std::size_t > > > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dispatchRangeToThreads", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dispatchRangeToThreads" "', argument " "1"" of type '" "gum::Idx""'");
  } 
  arg1 = static_cast< gum::Idx >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dispatchRangeToThreads" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dispatchRangeToThreads" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = gum::dispatchRangeToThreads(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::pair< gum::Idx,gum::Idx >,std::allocator< std::pair< gum::Idx,gum::Idx > > >(result)), SWIGTYPE_p_std__vectorT_std__pairT_std__size_t_std__size_t_t_std__allocatorT_std__pairT_std__size_t_std__size_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::mt19937 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "generator", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (std::mt19937 *) &gum::_rand_namespace_::generator();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mt19937, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randomValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  gum::Idx result;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::Idx result;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_randomValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_randomValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  (void)self;
  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_currentRandomGeneratorValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "currentRandomGeneratorValue", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (unsigned int)gum::currentRandomGeneratorValue();
    } 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_initRandom__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_initRandom__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_randomGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::mt19937 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "randomGenerator", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (std::mt19937 *) &gum::randomGenerator();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mt19937, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Variable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Variable *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = 0 ;
  gum::Variable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Variable_setName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VarType result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 = NULL;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_isEmpirical(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_isEmpirical" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = (bool)((gum::DiscreteVariable const *)arg1)->isEmpirical();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_closestIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DiscreteVariable_closestIndex", 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_closestIndex" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscreteVariable_closestIndex" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = ((gum::DiscreteVariable const *)arg1)->closestIndex(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_closestLabel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DiscreteVariable_closestLabel", 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_closestLabel" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscreteVariable_closestLabel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = ((gum::DiscreteVariable const *)arg1)->closestLabel(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_varType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VarType result;
  
  (void)self;
  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_toFast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_toFast" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = ((gum::DiscreteVariable const *)arg1)->toFast();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_stype(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_stype" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = ((gum::DiscreteVariable const *)arg1)->stype();
    } 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_asLabelizedVar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::LabelizedVariable > result;
  
  (void)self;
  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_asLabelizedVar" "', argument " "1"" of type '" "gum::DiscreteVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = gum_DiscreteVariable_asLabelizedVar(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::LabelizedVariable(result)), SWIGTYPE_p_gum__LabelizedVariable, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_asRangeVar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::RangeVariable > result;
  
  (void)self;
  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_asRangeVar" "', argument " "1"" of type '" "gum::DiscreteVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = gum_DiscreteVariable_asRangeVar(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::RangeVariable(result)), SWIGTYPE_p_gum__RangeVariable, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_asIntegerVar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::IntegerVariable > result;
  
  (void)self;
  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_asIntegerVar" "', argument " "1"" of type '" "gum::DiscreteVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = gum_DiscreteVariable_asIntegerVar(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::IntegerVariable(result)), SWIGTYPE_p_gum__IntegerVariable, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_asNumericalDiscreteVar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::NumericalDiscreteVariable > result;
  
  (void)self;
  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_asNumericalDiscreteVar" "', argument " "1"" of type '" "gum::DiscreteVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = gum_DiscreteVariable_asNumericalDiscreteVar(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NumericalDiscreteVariable(result)), SWIGTYPE_p_gum__NumericalDiscreteVariable, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_asDiscretizedVar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::DiscretizedVariable< double > > result;
  
  (void)self;
  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_asDiscretizedVar" "', argument " "1"" of type '" "gum::DiscreteVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = gum_DiscreteVariable_asDiscretizedVar(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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 = NULL;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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,SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::LabelizedVariable *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_NullReferenceError, "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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__LabelizedVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_LabelizedVariable__SWIG_4(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_LabelizedVariable__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_LabelizedVariable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_LabelizedVariable__SWIG_0(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_LabelizedVariable__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::LabelizedVariable *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::LabelizedVariable *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 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] ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "LabelizedVariable_changeLabel" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      ((gum::LabelizedVariable const *)arg1)->changeLabel(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_closestIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LabelizedVariable_closestIndex", 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_closestIndex" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LabelizedVariable_closestIndex" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = ((gum::LabelizedVariable const *)arg1)->closestIndex(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_domainSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VarType result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_stype(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_stype" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    try {
      result = ((gum::LabelizedVariable const *)arg1)->stype();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_toFast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_toFast" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    try {
      result = ((gum::LabelizedVariable const *)arg1)->toFast();
    } 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 = NULL;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_RangeVariable__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_RangeVariable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_RangeVariable__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 &)\n"
    "    gum::RangeVariable::RangeVariable(gum::RangeVariable const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RangeVariable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::RangeVariable *result = 0 ;
  
  (void)self;
  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::RangeVariable *)((gum::RangeVariable const *)arg1)->clone();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_domainSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VarType result;
  
  (void)self;
  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_toFast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_toFast" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  {
    try {
      result = ((gum::RangeVariable const *)arg1)->toFast();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_minVal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  (void)self;
  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_NullReferenceError, "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_closestIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RangeVariable_closestIndex", 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_closestIndex" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RangeVariable_closestIndex" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = ((gum::RangeVariable const *)arg1)->closestIndex(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_domain(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_stype(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_stype" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  {
    try {
      result = ((gum::RangeVariable const *)arg1)->stype();
    } 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 = NULL;
  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_new_IntegerVariable__SWIG_0(PyObject *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::IntegerVariable *result = 0 ;
  
  (void)self;
  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_IntegerVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IntegerVariable" "', 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_IntegerVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IntegerVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::IntegerVariable *)new gum::IntegerVariable((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IntegerVariable, 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_IntegerVariable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::IntegerVariable *result = 0 ;
  
  (void)self;
  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_IntegerVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IntegerVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::IntegerVariable *)new gum::IntegerVariable((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IntegerVariable, 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_IntegerVariable__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< int,std::allocator< int > > *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::IntegerVariable *result = 0 ;
  
  (void)self;
  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_IntegerVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IntegerVariable" "', 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_IntegerVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IntegerVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_IntegerVariable" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IntegerVariable" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (gum::IntegerVariable *)new gum::IntegerVariable((std::string const &)*arg1,(std::string const &)*arg2,(std::vector< int,std::allocator< int > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IntegerVariable, 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_IntegerVariable__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  gum::Size arg5 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  gum::IntegerVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) 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_IntegerVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IntegerVariable" "', 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_IntegerVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IntegerVariable" "', 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 '" "new_IntegerVariable" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_IntegerVariable" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_IntegerVariable" "', argument " "5"" of type '" "gum::Size""'");
  } 
  arg5 = static_cast< gum::Size >(val5);
  {
    try {
      result = (gum::IntegerVariable *)new gum::IntegerVariable((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,SWIG_STD_MOVE(arg5));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IntegerVariable, 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_IntegerVariable__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::IntegerVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__IntegerVariable,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntegerVariable" "', argument " "1"" of type '" "gum::IntegerVariable const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IntegerVariable" "', argument " "1"" of type '" "gum::IntegerVariable const &""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  {
    try {
      result = (gum::IntegerVariable *)new gum::IntegerVariable((gum::IntegerVariable const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IntegerVariable, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntegerVariable__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< gum::IntegerVariable > rvrdeleter1 ;
  gum::IntegerVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__IntegerVariable, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntegerVariable" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "gum::IntegerVariable &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntegerVariable" "', argument " "1"" of type '" "gum::IntegerVariable &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IntegerVariable" "', argument " "1"" of type '" "gum::IntegerVariable &&""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    try {
      result = (gum::IntegerVariable *)new gum::IntegerVariable((gum::IntegerVariable &&)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IntegerVariable, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntegerVariable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IntegerVariable", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__IntegerVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_IntegerVariable__SWIG_4(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IntegerVariable, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_IntegerVariable__SWIG_5(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_IntegerVariable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_IntegerVariable__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_IntegerVariable__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_new_IntegerVariable__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IntegerVariable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::IntegerVariable::IntegerVariable(std::string const &,std::string const &)\n"
    "    gum::IntegerVariable::IntegerVariable(std::string const &)\n"
    "    gum::IntegerVariable::IntegerVariable(std::string const &,std::string const &,std::vector< int,std::allocator< int > > const &)\n"
    "    gum::IntegerVariable::IntegerVariable(std::string const &,std::string const &,int,int,gum::Size)\n"
    "    gum::IntegerVariable::IntegerVariable(gum::IntegerVariable const &)\n"
    "    gum::IntegerVariable::IntegerVariable(gum::IntegerVariable &&)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntegerVariable_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IntegerVariable *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_clone" "', argument " "1"" of type '" "gum::IntegerVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  {
    try {
      result = (gum::IntegerVariable *)((gum::IntegerVariable const *)arg1)->clone();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_IntegerVariable_domainSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_domainSize" "', argument " "1"" of type '" "gum::IntegerVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  {
    try {
      result = ((gum::IntegerVariable 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_IntegerVariable_varType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VarType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_varType" "', argument " "1"" of type '" "gum::IntegerVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  {
    try {
      result = (gum::VarType)((gum::IntegerVariable const *)arg1)->varType();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_IntegerVariable_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IntegerVariable_index", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_index" "', argument " "1"" of type '" "gum::IntegerVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntegerVariable_index" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IntegerVariable_index" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::IntegerVariable 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_IntegerVariable_closestIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IntegerVariable_closestIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_closestIndex" "', argument " "1"" of type '" "gum::IntegerVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegerVariable_closestIndex" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = ((gum::IntegerVariable const *)arg1)->closestIndex(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntegerVariable_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IntegerVariable_label", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_label" "', argument " "1"" of type '" "gum::IntegerVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegerVariable_label" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = ((gum::IntegerVariable const *)arg1)->label(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntegerVariable_numerical(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IntegerVariable_numerical", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_numerical" "', argument " "1"" of type '" "gum::IntegerVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegerVariable_numerical" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = (double)((gum::IntegerVariable const *)arg1)->numerical(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntegerVariable_domain(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_domain" "', argument " "1"" of type '" "gum::IntegerVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  {
    try {
      result = ((gum::IntegerVariable 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_IntegerVariable_stype(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_stype" "', argument " "1"" of type '" "gum::IntegerVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  {
    try {
      result = ((gum::IntegerVariable const *)arg1)->stype();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntegerVariable_integerDomain(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_integerDomain" "', argument " "1"" of type '" "gum::IntegerVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  {
    try {
      result = (std::vector< int,std::allocator< int > > *) &((gum::IntegerVariable const *)arg1)->integerDomain();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntegerVariable_addValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IntegerVariable_addValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_addValue" "', argument " "1"" of type '" "gum::IntegerVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegerVariable_addValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->addValue(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntegerVariable_isValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IntegerVariable_isValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_isValue" "', argument " "1"" of type '" "gum::IntegerVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegerVariable_isValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (bool)((gum::IntegerVariable const *)arg1)->isValue(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntegerVariable_changeValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IntegerVariable_changeValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_changeValue" "', argument " "1"" of type '" "gum::IntegerVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegerVariable_changeValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntegerVariable_changeValue" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      (arg1)->changeValue(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntegerVariable_eraseValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IntegerVariable_eraseValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_eraseValue" "', argument " "1"" of type '" "gum::IntegerVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegerVariable_eraseValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->eraseValue(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_IntegerVariable_closestLabel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IntegerVariable *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IntegerVariable_closestLabel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IntegerVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerVariable_closestLabel" "', argument " "1"" of type '" "gum::IntegerVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IntegerVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegerVariable_closestLabel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = ((gum::IntegerVariable const *)arg1)->closestLabel(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


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


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


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

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

SWIGINTERN PyObject *_wrap_new_NumericalDiscreteVariable__SWIG_0(PyObject *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::NumericalDiscreteVariable *result = 0 ;
  
  (void)self;
  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_NumericalDiscreteVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NumericalDiscreteVariable" "', 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_NumericalDiscreteVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NumericalDiscreteVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::NumericalDiscreteVariable *)new gum::NumericalDiscreteVariable((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NumericalDiscreteVariable, 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_NumericalDiscreteVariable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::NumericalDiscreteVariable *result = 0 ;
  
  (void)self;
  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_NumericalDiscreteVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NumericalDiscreteVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::NumericalDiscreteVariable *)new gum::NumericalDiscreteVariable((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NumericalDiscreteVariable, 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_NumericalDiscreteVariable__SWIG_2(PyObject *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::NumericalDiscreteVariable *result = 0 ;
  
  (void)self;
  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_NumericalDiscreteVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NumericalDiscreteVariable" "', 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_NumericalDiscreteVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NumericalDiscreteVariable" "', 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_NumericalDiscreteVariable" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NumericalDiscreteVariable" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (gum::NumericalDiscreteVariable *)new gum::NumericalDiscreteVariable((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__NumericalDiscreteVariable, 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_NumericalDiscreteVariable__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  gum::Size arg5 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  gum::NumericalDiscreteVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) 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_NumericalDiscreteVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NumericalDiscreteVariable" "', 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_NumericalDiscreteVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NumericalDiscreteVariable" "', 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 '" "new_NumericalDiscreteVariable" "', 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 '" "new_NumericalDiscreteVariable" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NumericalDiscreteVariable" "', argument " "5"" of type '" "gum::Size""'");
  } 
  arg5 = static_cast< gum::Size >(val5);
  {
    try {
      result = (gum::NumericalDiscreteVariable *)new gum::NumericalDiscreteVariable((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,SWIG_STD_MOVE(arg5));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NumericalDiscreteVariable, 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_NumericalDiscreteVariable__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NumericalDiscreteVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__NumericalDiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NumericalDiscreteVariable" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NumericalDiscreteVariable" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable const &""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  {
    try {
      result = (gum::NumericalDiscreteVariable *)new gum::NumericalDiscreteVariable((gum::NumericalDiscreteVariable const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NumericalDiscreteVariable, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumericalDiscreteVariable__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< gum::NumericalDiscreteVariable > rvrdeleter1 ;
  gum::NumericalDiscreteVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__NumericalDiscreteVariable, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NumericalDiscreteVariable" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "gum::NumericalDiscreteVariable &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NumericalDiscreteVariable" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NumericalDiscreteVariable" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable &&""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    try {
      result = (gum::NumericalDiscreteVariable *)new gum::NumericalDiscreteVariable((gum::NumericalDiscreteVariable &&)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NumericalDiscreteVariable, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumericalDiscreteVariable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NumericalDiscreteVariable", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__NumericalDiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_NumericalDiscreteVariable__SWIG_4(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__NumericalDiscreteVariable, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_NumericalDiscreteVariable__SWIG_5(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_NumericalDiscreteVariable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_NumericalDiscreteVariable__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_NumericalDiscreteVariable__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_new_NumericalDiscreteVariable__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NumericalDiscreteVariable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::NumericalDiscreteVariable::NumericalDiscreteVariable(std::string const &,std::string const &)\n"
    "    gum::NumericalDiscreteVariable::NumericalDiscreteVariable(std::string const &)\n"
    "    gum::NumericalDiscreteVariable::NumericalDiscreteVariable(std::string const &,std::string const &,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::NumericalDiscreteVariable::NumericalDiscreteVariable(std::string const &,std::string const &,double,double,gum::Size)\n"
    "    gum::NumericalDiscreteVariable::NumericalDiscreteVariable(gum::NumericalDiscreteVariable const &)\n"
    "    gum::NumericalDiscreteVariable::NumericalDiscreteVariable(gum::NumericalDiscreteVariable &&)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NumericalDiscreteVariable_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NumericalDiscreteVariable *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_clone" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  {
    try {
      result = (gum::NumericalDiscreteVariable *)((gum::NumericalDiscreteVariable const *)arg1)->clone();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_NumericalDiscreteVariable_domainSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_domainSize" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  {
    try {
      result = ((gum::NumericalDiscreteVariable 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_NumericalDiscreteVariable_varType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VarType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_varType" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  {
    try {
      result = (gum::VarType)((gum::NumericalDiscreteVariable const *)arg1)->varType();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_NumericalDiscreteVariable_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NumericalDiscreteVariable_index", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_index" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NumericalDiscreteVariable_index" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "NumericalDiscreteVariable_index" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::NumericalDiscreteVariable 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_NumericalDiscreteVariable_closestIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NumericalDiscreteVariable_closestIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_closestIndex" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NumericalDiscreteVariable_closestIndex" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = ((gum::NumericalDiscreteVariable const *)arg1)->closestIndex(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NumericalDiscreteVariable_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NumericalDiscreteVariable_label", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_label" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NumericalDiscreteVariable_label" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = ((gum::NumericalDiscreteVariable const *)arg1)->label(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NumericalDiscreteVariable_numerical(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NumericalDiscreteVariable_numerical", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_numerical" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NumericalDiscreteVariable_numerical" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = (double)((gum::NumericalDiscreteVariable const *)arg1)->numerical(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NumericalDiscreteVariable_domain(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_domain" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  {
    try {
      result = ((gum::NumericalDiscreteVariable 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_NumericalDiscreteVariable_stype(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_stype" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  {
    try {
      result = ((gum::NumericalDiscreteVariable const *)arg1)->stype();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NumericalDiscreteVariable_numericalDomain(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_numericalDomain" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &((gum::NumericalDiscreteVariable const *)arg1)->numericalDomain();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NumericalDiscreteVariable_addValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NumericalDiscreteVariable_addValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_addValue" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NumericalDiscreteVariable_addValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      (arg1)->addValue(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NumericalDiscreteVariable_isValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NumericalDiscreteVariable_isValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_isValue" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NumericalDiscreteVariable_isValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (bool)((gum::NumericalDiscreteVariable const *)arg1)->isValue(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NumericalDiscreteVariable_changeValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NumericalDiscreteVariable_changeValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_changeValue" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NumericalDiscreteVariable_changeValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NumericalDiscreteVariable_changeValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      (arg1)->changeValue(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NumericalDiscreteVariable_eraseValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NumericalDiscreteVariable_eraseValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_eraseValue" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NumericalDiscreteVariable_eraseValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      (arg1)->eraseValue(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_NumericalDiscreteVariable_closestLabel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::NumericalDiscreteVariable *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NumericalDiscreteVariable_closestLabel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NumericalDiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumericalDiscreteVariable_closestLabel" "', argument " "1"" of type '" "gum::NumericalDiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::NumericalDiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NumericalDiscreteVariable_closestLabel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = ((gum::NumericalDiscreteVariable const *)arg1)->closestLabel(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


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


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


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

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

SWIGINTERN PyObject *_wrap_delete_IDiscretizedVariable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IDiscretizedVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IDiscretizedVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IDiscretizedVariable *result = 0 ;
  
  (void)self;
  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 *_wrap_IDiscretizedVariable_isEmpirical(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IDiscretizedVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_isEmpirical" "', argument " "1"" of type '" "gum::IDiscretizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IDiscretizedVariable * >(argp1);
  {
    try {
      result = (bool)((gum::IDiscretizedVariable const *)arg1)->isEmpirical();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IDiscretizedVariable_setEmpirical(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IDiscretizedVariable *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IDiscretizedVariable_setEmpirical", 2, 2, swig_obj)) SWIG_fail;
  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_setEmpirical" "', argument " "1"" of type '" "gum::IDiscretizedVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::IDiscretizedVariable * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IDiscretizedVariable_setEmpirical" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setEmpirical(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IDiscretizedVariable_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IDiscretizedVariable *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IDiscretizedVariable_draw", 2, 2, swig_obj)) SWIG_fail;
  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_draw" "', argument " "1"" of type '" "gum::IDiscretizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IDiscretizedVariable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IDiscretizedVariable_draw" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = (double)((gum::IDiscretizedVariable const *)arg1)->draw(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IDiscretizedVariable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_Edge__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Edge__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Edge *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Edge *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Edge *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Edge *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Edge *arg1 = 0 ;
  gum::Edge *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *Edge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_Arc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Arc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *Arc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 int Swig_var_emptyNodeSet_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable emptyNodeSet is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_emptyNodeSet_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&gum::emptyNodeSet), SWIGTYPE_p_gum__SetT_std__size_t_t,  0 );
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_UndiGraph__SWIG_0(PyObject *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  gum::UndiGraph *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::UndiGraph *result = 0 ;
  
  (void)self;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_UndiGraph__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_UndiGraph__SWIG_5(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_UndiGraph__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_UndiGraph__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_UndiGraph__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_UndiGraph__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_completeGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::UndiGraph result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UndiGraph_completeGraph" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = gum::UndiGraph::completeGraph(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  gum::UndiGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_UndiGraph___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  gum::UndiGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_UndiGraph_addEdge__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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 {
      (arg1)->addEdge(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_eraseNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_nodes2ConnectedComponent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::NodeProperty< std::size_t > > result;
  
  (void)self;
  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_nodes2ConnectedComponent" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = ((gum::UndiGraph const *)arg1)->nodes2ConnectedComponent();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeProperty< gum::NodeId >(result)), SWIGTYPE_p_gum__NodePropertyT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = (PyObject *)gum_UndiGraph_edges((gum::UndiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_neighbours(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 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_neighbours" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_UndiGraph_neighbours((gum::UndiGraph const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_addNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_existsNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_addEdge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UndiGraph_addEdge", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_UndiGraph_addEdge__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_UndiGraph_addEdge__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UndiGraph_addEdge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UndiGraph::addEdge(gum::NodeId,gum::NodeId)\n"
    "    gum::UndiGraph::addEdge(gum::NodeId const,gum::NodeId const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UndiGraph_eraseEdge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 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] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_existsEdge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 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;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_sizeEdges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(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 = NULL;
  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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  gum::DiGraph *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::DiGraph *result = 0 ;
  
  (void)self;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_DiGraph__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_DiGraph__SWIG_5(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DiGraph__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DiGraph__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DiGraph__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_DiGraph__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_completeGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DiGraph result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DiGraph_completeGraph" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = gum::DiGraph::completeGraph(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::DiGraph(result)), SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  gum::DiGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_DiGraph_addArc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_eraseNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::Sequence< std::size_t > > result;
  
  (void)self;
  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_topologicalOrder" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = ((gum::DiGraph const *)arg1)->topologicalOrder();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    PyObject *q=PyList_New(0);
    
    PyObject *pyval;
    for(auto i : static_cast<gum::Sequence<gum::NodeId>>(result)) {
      pyval=PyInt_FromLong(i);
      PyList_Append(q,pyval);
      Py_DecRef(pyval);
    }
    resultobj=q;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_hasDirectedPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 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;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_hasDirectedPath", 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_hasDirectedPath" "', 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_hasDirectedPath" "', 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_hasDirectedPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)(arg1)->hasDirectedPath(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_arcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 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_parents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_DiGraph_parents((gum::DiGraph const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 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_children" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_DiGraph_children((gum::DiGraph const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_addNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_existsNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_DiGraph_addArc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_DiGraph_addArc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 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] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_existsArc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 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;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_eraseParents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_eraseChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_sizeArcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 = NULL;
  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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  gum::DAG *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::DAG *result = 0 ;
  
  (void)self;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_DAG__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_DAG__SWIG_5(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DAG__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DAG__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DAG__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_DAG__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_moralGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::UndiGraph result;
  
  (void)self;
  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(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_moralizedAncestralGraph__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::UndiGraph result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) 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_moralizedAncestralGraph" "', argument " "1"" of type '" "gum::DAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(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 '" "DAG_moralizedAncestralGraph" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAG_moralizedAncestralGraph" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeSet * >(argp2);
  {
    try {
      result = ((gum::DAG const *)arg1)->moralizedAncestralGraph((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_dSeparation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  gum::NodeSet *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) 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_dSeparation" "', 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_dSeparation" "', 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_dSeparation" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DAG_dSeparation" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAG_dSeparation" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  arg4 = reinterpret_cast< gum::NodeSet * >(argp4);
  {
    try {
      result = (bool)((gum::DAG const *)arg1)->dSeparation(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(gum::NodeSet const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_dSeparation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  gum::NodeSet *arg3 = 0 ;
  gum::NodeSet *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) 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_dSeparation" "', argument " "1"" of type '" "gum::DAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(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 '" "DAG_dSeparation" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAG_dSeparation" "', 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 '" "DAG_dSeparation" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAG_dSeparation" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DAG_dSeparation" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAG_dSeparation" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  arg4 = reinterpret_cast< gum::NodeSet * >(argp4);
  {
    try {
      result = (bool)((gum::DAG const *)arg1)->dSeparation((gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3,(gum::NodeSet const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_minimalCondSet__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 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;
  
  (void)self;
  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_minimalCondSet" "', 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_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 '" "DAG_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAG_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = ((gum::DAG const *)arg1)->minimalCondSet(SWIG_STD_MOVE(arg2),(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_minimalCondSet__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 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;
  
  (void)self;
  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_minimalCondSet" "', argument " "1"" of type '" "gum::DAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(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 '" "DAG_minimalCondSet" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAG_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 '" "DAG_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAG_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = ((gum::DAG const *)arg1)->minimalCondSet((gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_minimalCondSet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAG_minimalCondSet", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      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) goto check_1;
    PyObject *retobj = _wrap_DAG_minimalCondSet__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_DAG_minimalCondSet__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAG_minimalCondSet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAG::minimalCondSet(gum::NodeId,gum::NodeSet const &) const\n"
    "    gum::DAG::minimalCondSet(gum::NodeSet const &,gum::NodeSet const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAG___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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___repr__" "', argument " "1"" of type '" "gum::DAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  {
    try {
      result = gum_DAG___repr__((gum::DAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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___str__" "', argument " "1"" of type '" "gum::DAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  {
    try {
      result = gum_DAG___str__((gum::DAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_dSeparation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) 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_dSeparation" "', argument " "1"" of type '" "gum::DAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  arg4 = swig_obj[3];
  {
    try {
      result = (bool)gum_DAG_dSeparation__SWIG_2(arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_dSeparation__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  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_dSeparation" "', argument " "1"" of type '" "gum::DAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (bool)gum_DAG_dSeparation__SWIG_3(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_dSeparation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAG_dSeparation", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_DAG_dSeparation__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      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) goto check_2;
    {
      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) goto check_2;
    {
      int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_DAG_dSeparation__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_DAG_dSeparation__SWIG_0(self, argc, argv);
  }
check_3:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_DAG_dSeparation__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAG_dSeparation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAG::dSeparation(gum::NodeId,gum::NodeId,gum::NodeSet const &) const\n"
    "    gum::DAG::dSeparation(gum::NodeSet const &,gum::NodeSet const &,gum::NodeSet const &) const\n"
    "    gum::DAG::dSeparation(PyObject *,PyObject *,PyObject *)\n"
    "    gum::DAG::dSeparation(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAG_moralizedAncestralGraph__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::UndiGraph result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) 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_moralizedAncestralGraph" "', argument " "1"" of type '" "gum::DAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_DAG_moralizedAncestralGraph__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_moralizedAncestralGraph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAG_moralizedAncestralGraph", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      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) goto check_1;
    return _wrap_DAG_moralizedAncestralGraph__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_DAG_moralizedAncestralGraph__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAG_moralizedAncestralGraph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAG::moralizedAncestralGraph(gum::NodeSet const &) const\n"
    "    gum::DAG::moralizedAncestralGraph(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAG_addNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_arcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_arcs" "', argument " "1"" of type '" "gum::DAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  {
    try {
      result = (PyObject *)gum_DAG_arcs((gum::DAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_parents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DAG_parents", 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_parents" "', 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_parents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_DAG_parents((gum::DAG const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DAG_children", 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_children" "', 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_children" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_DAG_children((gum::DAG const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_addArc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_DAG_addArc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_DAG_addArc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,gum::NodeId)\n"
    "    gum::DAG::addArc(gum::NodeId const,gum::NodeId const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAG_eraseArc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DAG_eraseArc", 3, 3, 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_eraseArc" "', 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_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 '" "DAG_eraseArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_DAG_eraseArc(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_existsArc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 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;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DAG_existsArc", 3, 3, 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_existsArc" "', 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_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 '" "DAG_existsArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)gum_DAG_existsArc((gum::DAG const *)arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_eraseParents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DAG_eraseParents", 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_eraseParents" "', 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_eraseParents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_DAG_eraseParents(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_eraseChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DAG_eraseChildren", 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_eraseChildren" "', 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_eraseChildren" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_DAG_eraseChildren(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_sizeArcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_sizeArcs" "', argument " "1"" of type '" "gum::DAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  {
    try {
      result = gum_DAG_sizeArcs((gum::DAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_emptyArcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_emptyArcs" "', argument " "1"" of type '" "gum::DAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  {
    try {
      result = (bool)gum_DAG_emptyArcs((gum::DAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DAG_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(arg3),arg4,SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(arg3),arg4,SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  gum::MixedGraph *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::MixedGraph *result = 0 ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::MixedGraph *result = 0 ;
  
  (void)self;
  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_MixedGraph" "', argument " "1"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MixedGraph" "', argument " "1"" of type '" "gum::UndiGraph const &""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = (gum::MixedGraph *)new gum::MixedGraph((gum::UndiGraph 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__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::MixedGraph *result = 0 ;
  
  (void)self;
  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_MixedGraph" "', argument " "1"" of type '" "gum::DiGraph const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MixedGraph" "', argument " "1"" of type '" "gum::DiGraph const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = (gum::MixedGraph *)new gum::MixedGraph((gum::DiGraph 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__SWIG_9(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_MixedGraph__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_MixedGraph__SWIG_9(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_MixedGraph__SWIG_8(self, argc, argv);
  }
check_3:
  
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_new_MixedGraph__SWIG_7(self, argc, argv);
  }
check_4:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_MixedGraph__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_MixedGraph__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_MixedGraph__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_MixedGraph__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_new_MixedGraph__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_new_MixedGraph__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::UndiGraph const &)\n"
    "    gum::MixedGraph::MixedGraph(gum::DiGraph const &)\n"
    "    gum::MixedGraph::MixedGraph(gum::MixedGraph const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MixedGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  gum::MixedGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_MixedGraph_eraseNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_hasMixedOrientedPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 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;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_hasMixedOrientedPath", 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_hasMixedOrientedPath" "', 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_hasMixedOrientedPath" "', 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_hasMixedOrientedPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)((gum::MixedGraph const *)arg1)->hasMixedOrientedPath(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_toDot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_chainComponent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_chainComponent", 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_chainComponent" "', 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_chainComponent" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::MixedGraph const *)arg1)->chainComponent(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *_wrap_MixedGraph_addNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_addNodes", 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_addNodes" "', 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_addNodes" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = (PyObject *)gum_MixedGraph_addNodes((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_arcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_arcs" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = (PyObject *)gum_MixedGraph_arcs((gum::MixedGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_parents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_parents", 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_parents" "', 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_parents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_MixedGraph_parents((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_children", 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_children" "', 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_children" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_MixedGraph_children((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_edges" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = (PyObject *)gum_MixedGraph_edges((gum::MixedGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_neighbours(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_neighbours", 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_neighbours" "', 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_neighbours" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_MixedGraph_neighbours((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_boundary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_boundary", 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_boundary" "', 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_boundary" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_MixedGraph_boundary((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_mixedOrientedPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 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 ;
  
  (void)self;
  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 = (PyObject *)gum_MixedGraph_mixedOrientedPath((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_mixedUnorientedPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 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 ;
  
  (void)self;
  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 = (PyObject *)gum_MixedGraph_mixedUnorientedPath((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_addNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  (void)self;
  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_addNode" "', argument " "1"" of type '" "gum::MixedGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = gum_MixedGraph_addNode(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_addNodeWithId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_addNodeWithId", 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_addNodeWithId" "', 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_addNodeWithId" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_MixedGraph_addNodeWithId(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_existsNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_existsNode", 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_existsNode" "', 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_existsNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_MixedGraph_existsNode((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_size" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = gum_MixedGraph_size((gum::MixedGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_empty" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = (bool)gum_MixedGraph_empty((gum::MixedGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_addEdge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_addEdge", 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_addEdge" "', 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_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 '" "MixedGraph_addEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_MixedGraph_addEdge(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_eraseEdge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_eraseEdge", 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_eraseEdge" "', 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_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 '" "MixedGraph_eraseEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_MixedGraph_eraseEdge(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_existsEdge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 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;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_existsEdge", 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_existsEdge" "', 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_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 '" "MixedGraph_existsEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)gum_MixedGraph_existsEdge((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_sizeEdges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_sizeEdges" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = gum_MixedGraph_sizeEdges((gum::MixedGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_emptyEdges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_emptyEdges" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = (bool)gum_MixedGraph_emptyEdges((gum::MixedGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_eraseNeighbours(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_eraseNeighbours", 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_eraseNeighbours" "', 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_eraseNeighbours" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_MixedGraph_eraseNeighbours(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_addArc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_addArc", 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_addArc" "', 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_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 '" "MixedGraph_addArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_MixedGraph_addArc(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_eraseArc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_eraseArc", 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_eraseArc" "', 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_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 '" "MixedGraph_eraseArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_MixedGraph_eraseArc(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_existsArc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 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;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_existsArc", 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_existsArc" "', 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_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 '" "MixedGraph_existsArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)gum_MixedGraph_existsArc((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_eraseParents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_eraseParents", 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_eraseParents" "', 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_eraseParents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_MixedGraph_eraseParents(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_eraseChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_eraseChildren", 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_eraseChildren" "', 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_eraseChildren" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_MixedGraph_eraseChildren(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_sizeArcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_sizeArcs" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = gum_MixedGraph_sizeArcs((gum::MixedGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_emptyArcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_emptyArcs" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = (bool)gum_MixedGraph_emptyArcs((gum::MixedGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MixedGraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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_PDAG__SWIG_0(PyObject *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::PDAG *result = 0 ;
  
  (void)self;
  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_PDAG" "', 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_PDAG" "', 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_PDAG" "', 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_PDAG" "', 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_PDAG" "', 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_PDAG" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (gum::PDAG *)new gum::PDAG(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(arg3),arg4,SWIG_STD_MOVE(arg5),arg6);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PDAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PDAG__SWIG_1(PyObject *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::PDAG *result = 0 ;
  
  (void)self;
  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_PDAG" "', 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_PDAG" "', 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_PDAG" "', 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_PDAG" "', 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_PDAG" "', argument " "5"" of type '" "gum::Size""'");
  } 
  arg5 = static_cast< gum::Size >(val5);
  {
    try {
      result = (gum::PDAG *)new gum::PDAG(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(arg3),arg4,SWIG_STD_MOVE(arg5));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PDAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PDAG__SWIG_2(PyObject *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::PDAG *result = 0 ;
  
  (void)self;
  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_PDAG" "', 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_PDAG" "', 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_PDAG" "', 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_PDAG" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (gum::PDAG *)new gum::PDAG(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(arg3),arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PDAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PDAG__SWIG_3(PyObject *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::PDAG *result = 0 ;
  
  (void)self;
  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_PDAG" "', 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_PDAG" "', 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_PDAG" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  {
    try {
      result = (gum::PDAG *)new gum::PDAG(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PDAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PDAG__SWIG_4(PyObject *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::PDAG *result = 0 ;
  
  (void)self;
  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_PDAG" "', 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_PDAG" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::PDAG *)new gum::PDAG(SWIG_STD_MOVE(arg1),arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PDAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PDAG__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  gum::PDAG *result = 0 ;
  
  (void)self;
  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_PDAG" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  {
    try {
      result = (gum::PDAG *)new gum::PDAG(SWIG_STD_MOVE(arg1));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PDAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_PDAG__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::PDAG *result = 0 ;
  
  (void)self;
  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_PDAG" "', argument " "1"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PDAG" "', argument " "1"" of type '" "gum::UndiGraph const &""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = (gum::PDAG *)new gum::PDAG((gum::UndiGraph const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PDAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PDAG__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::PDAG *result = 0 ;
  
  (void)self;
  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_PDAG" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PDAG" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  {
    try {
      result = (gum::PDAG *)new gum::PDAG((gum::DAG const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PDAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PDAG__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::PDAG *result = 0 ;
  
  (void)self;
  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_PDAG" "', argument " "1"" of type '" "gum::MixedGraph const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PDAG" "', argument " "1"" of type '" "gum::MixedGraph const &""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = (gum::PDAG *)new gum::PDAG((gum::MixedGraph const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PDAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_PDAG(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PDAG", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_PDAG__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__PDAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_PDAG__SWIG_10(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_PDAG__SWIG_8(self, argc, argv);
  }
check_3:
  
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_new_PDAG__SWIG_9(self, argc, argv);
  }
check_4:
  
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    return _wrap_new_PDAG__SWIG_7(self, argc, argv);
  }
check_5:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_PDAG__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_PDAG__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_PDAG__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_PDAG__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_new_PDAG__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_new_PDAG__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PDAG'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::PDAG::PDAG(gum::Size,bool,gum::Size,bool,gum::Size,bool)\n"
    "    gum::PDAG::PDAG(gum::Size,bool,gum::Size,bool,gum::Size)\n"
    "    gum::PDAG::PDAG(gum::Size,bool,gum::Size,bool)\n"
    "    gum::PDAG::PDAG(gum::Size,bool,gum::Size)\n"
    "    gum::PDAG::PDAG(gum::Size,bool)\n"
    "    gum::PDAG::PDAG(gum::Size)\n"
    "    gum::PDAG::PDAG()\n"
    "    gum::PDAG::PDAG(gum::UndiGraph const &)\n"
    "    gum::PDAG::PDAG(gum::DAG const &)\n"
    "    gum::PDAG::PDAG(gum::MixedGraph const &)\n"
    "    gum::PDAG::PDAG(gum::PDAG const &)\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_PDAG_addArc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_addArc" "', argument " "1"" of type '" "gum::PDAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_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 '" "PDAG_addArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->addArc(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_addEdge__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_addEdge" "', argument " "1"" of type '" "gum::PDAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_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 '" "PDAG_addEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->addEdge(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_moralGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::UndiGraph result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_moralGraph" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    try {
      result = ((gum::PDAG const *)arg1)->moralGraph();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_moralizedAncestralGraph__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::UndiGraph result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_moralizedAncestralGraph" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(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 '" "PDAG_moralizedAncestralGraph" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PDAG_moralizedAncestralGraph" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeSet * >(argp2);
  {
    try {
      result = ((gum::PDAG const *)arg1)->moralizedAncestralGraph((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_hasMixedReallyOrientedPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 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;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_hasMixedReallyOrientedPath", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_hasMixedReallyOrientedPath" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_hasMixedReallyOrientedPath" "', 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 '" "PDAG_hasMixedReallyOrientedPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)((gum::PDAG const *)arg1)->hasMixedReallyOrientedPath(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_cSeparation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  gum::NodeSet *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_cSeparation" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_cSeparation" "', 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 '" "PDAG_cSeparation" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PDAG_cSeparation" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PDAG_cSeparation" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  arg4 = reinterpret_cast< gum::NodeSet * >(argp4);
  {
    try {
      result = (bool)((gum::PDAG const *)arg1)->cSeparation(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(gum::NodeSet const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_cSeparation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  gum::NodeSet *arg3 = 0 ;
  gum::NodeSet *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_cSeparation" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(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 '" "PDAG_cSeparation" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PDAG_cSeparation" "', 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 '" "PDAG_cSeparation" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PDAG_cSeparation" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PDAG_cSeparation" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PDAG_cSeparation" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  arg4 = reinterpret_cast< gum::NodeSet * >(argp4);
  {
    try {
      result = (bool)((gum::PDAG const *)arg1)->cSeparation((gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3,(gum::NodeSet const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_toDot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_toDot" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    try {
      result = ((gum::PDAG 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_PDAG___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG___repr__" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    try {
      result = gum_PDAG___repr__((gum::PDAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_PDAG_cSeparation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_cSeparation" "', argument " "1"" of type '" "gum::PDAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  arg4 = swig_obj[3];
  {
    try {
      result = (bool)gum_PDAG_cSeparation__SWIG_2(arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_cSeparation__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_cSeparation" "', argument " "1"" of type '" "gum::PDAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (bool)gum_PDAG_cSeparation__SWIG_3(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_cSeparation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PDAG_cSeparation", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_PDAG_cSeparation__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      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) goto check_2;
    {
      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) goto check_2;
    {
      int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_PDAG_cSeparation__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_PDAG_cSeparation__SWIG_0(self, argc, argv);
  }
check_3:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_PDAG_cSeparation__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PDAG_cSeparation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::PDAG::cSeparation(gum::NodeId,gum::NodeId,gum::NodeSet const &) const\n"
    "    gum::PDAG::cSeparation(gum::NodeSet const &,gum::NodeSet const &,gum::NodeSet const &) const\n"
    "    gum::PDAG::cSeparation(PyObject *,PyObject *,PyObject *)\n"
    "    gum::PDAG::cSeparation(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PDAG_moralizedAncestralGraph__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::UndiGraph result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_moralizedAncestralGraph" "', argument " "1"" of type '" "gum::PDAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_PDAG_moralizedAncestralGraph__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_moralizedAncestralGraph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PDAG_moralizedAncestralGraph", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      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) goto check_1;
    return _wrap_PDAG_moralizedAncestralGraph__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_PDAG_moralizedAncestralGraph__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PDAG_moralizedAncestralGraph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::PDAG::moralizedAncestralGraph(gum::NodeSet const &) const\n"
    "    gum::PDAG::moralizedAncestralGraph(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PDAG_addNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_addNodes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_addNodes" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_addNodes" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = (PyObject *)gum_PDAG_addNodes((gum::PDAG const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_arcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_arcs" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    try {
      result = (PyObject *)gum_PDAG_arcs((gum::PDAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_parents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_parents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_parents" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_parents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_PDAG_parents((gum::PDAG const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_children", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_children" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_children" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_PDAG_children((gum::PDAG const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_edges" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    try {
      result = (PyObject *)gum_PDAG_edges((gum::PDAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_neighbours(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_neighbours", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_neighbours" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_neighbours" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_PDAG_neighbours((gum::PDAG const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_boundary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_boundary", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_boundary" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_boundary" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_PDAG_boundary((gum::PDAG const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_mixedOrientedPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 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 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_mixedOrientedPath", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_mixedOrientedPath" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_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 '" "PDAG_mixedOrientedPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (PyObject *)gum_PDAG_mixedOrientedPath((gum::PDAG const *)arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_mixedUnorientedPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 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 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_mixedUnorientedPath", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_mixedUnorientedPath" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_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 '" "PDAG_mixedUnorientedPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (PyObject *)gum_PDAG_mixedUnorientedPath((gum::PDAG const *)arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_addNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_addNode" "', argument " "1"" of type '" "gum::PDAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    try {
      result = gum_PDAG_addNode(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_addNodeWithId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_addNodeWithId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_addNodeWithId" "', argument " "1"" of type '" "gum::PDAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_addNodeWithId" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_PDAG_addNodeWithId(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_existsNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_existsNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_existsNode" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_existsNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_PDAG_existsNode((gum::PDAG const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_size" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    try {
      result = gum_PDAG_size((gum::PDAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_empty" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    try {
      result = (bool)gum_PDAG_empty((gum::PDAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_addEdge__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_addEdge" "', argument " "1"" of type '" "gum::PDAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_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 '" "PDAG_addEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_PDAG_addEdge__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_addEdge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PDAG_addEdge", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_PDAG_addEdge__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_PDAG_addEdge__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PDAG_addEdge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::PDAG::addEdge(gum::NodeId,gum::NodeId)\n"
    "    gum::PDAG::addEdge(gum::NodeId const,gum::NodeId const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PDAG_eraseEdge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_eraseEdge", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_eraseEdge" "', argument " "1"" of type '" "gum::PDAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_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 '" "PDAG_eraseEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_PDAG_eraseEdge(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_existsEdge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 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;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_existsEdge", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_existsEdge" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_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 '" "PDAG_existsEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)gum_PDAG_existsEdge((gum::PDAG const *)arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_sizeEdges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_sizeEdges" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    try {
      result = gum_PDAG_sizeEdges((gum::PDAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_emptyEdges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_emptyEdges" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    try {
      result = (bool)gum_PDAG_emptyEdges((gum::PDAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_eraseNeighbours(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_eraseNeighbours", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_eraseNeighbours" "', argument " "1"" of type '" "gum::PDAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_eraseNeighbours" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_PDAG_eraseNeighbours(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_addArc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_addArc" "', argument " "1"" of type '" "gum::PDAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_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 '" "PDAG_addArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_PDAG_addArc__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_addArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PDAG_addArc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_PDAG_addArc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_PDAG_addArc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PDAG_addArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::PDAG::addArc(gum::NodeId,gum::NodeId)\n"
    "    gum::PDAG::addArc(gum::NodeId const,gum::NodeId const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PDAG_eraseArc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_eraseArc", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_eraseArc" "', argument " "1"" of type '" "gum::PDAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_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 '" "PDAG_eraseArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_PDAG_eraseArc(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_existsArc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 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;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_existsArc", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_existsArc" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_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 '" "PDAG_existsArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)gum_PDAG_existsArc((gum::PDAG const *)arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_eraseParents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_eraseParents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_eraseParents" "', argument " "1"" of type '" "gum::PDAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_eraseParents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_PDAG_eraseParents(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_eraseChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_eraseChildren", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_eraseChildren" "', argument " "1"" of type '" "gum::PDAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDAG_eraseChildren" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_PDAG_eraseChildren(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_sizeArcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_sizeArcs" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    try {
      result = gum_PDAG_sizeArcs((gum::PDAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_emptyArcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PDAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDAG_emptyArcs" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    try {
      result = (bool)gum_PDAG_emptyArcs((gum::PDAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_CliqueGraph__SWIG_0(PyObject *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  gum::CliqueGraph *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *result = 0 ;
  
  (void)self;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_CliqueGraph__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_CliqueGraph__SWIG_5(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_CliqueGraph__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_CliqueGraph__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_CliqueGraph__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_CliqueGraph__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 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] ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_eraseEdge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  gum::Edge *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeId result;
  
  (void)self;
  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(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CliqueGraph_addNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_CliqueGraph_addNode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_CliqueGraph_addNode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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");
  return 0;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_eraseNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 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] ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "CliqueGraph_setClique" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      (arg1)->setClique(SWIG_STD_MOVE(arg2),(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_addToClique(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 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] ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_eraseFromClique(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 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] ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_containerPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 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;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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___map_str____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string *arg5 = 0 ;
  std::string *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  std::string result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) 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___map_str__" "', argument " "1"" of type '" "gum::CliqueGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CliqueGraph___map_str__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CliqueGraph___map_str__" "', 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 '" "CliqueGraph___map_str__" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CliqueGraph___map_str__" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CliqueGraph___map_str__" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CliqueGraph___map_str__" "', argument " "6"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CliqueGraph___map_str__" "', argument " "6"" of type '" "std::string const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = ((gum::CliqueGraph const *)arg1)->mapToDot(arg2,arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph___map_str____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  std::string result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) 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___map_str__" "', argument " "1"" of type '" "gum::CliqueGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CliqueGraph___map_str__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CliqueGraph___map_str__" "', 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 '" "CliqueGraph___map_str__" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CliqueGraph___map_str__" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CliqueGraph___map_str__" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = ((gum::CliqueGraph const *)arg1)->mapToDot(arg2,arg3,arg4,(std::string const &)*arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph___map_str____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) 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___map_str__" "', argument " "1"" of type '" "gum::CliqueGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CliqueGraph___map_str__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CliqueGraph___map_str__" "', 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 '" "CliqueGraph___map_str__" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    try {
      result = ((gum::CliqueGraph const *)arg1)->mapToDot(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_CliqueGraph___map_str__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CliqueGraph___map_str__", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    PyObject *retobj = _wrap_CliqueGraph___map_str____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_CliqueGraph___map_str____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_CliqueGraph___map_str____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CliqueGraph___map_str__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CliqueGraph::mapToDot(double,double,double,std::string const &,std::string const &) const\n"
    "    gum::CliqueGraph::mapToDot(double,double,double,std::string const &) const\n"
    "    gum::CliqueGraph::mapToDot(double,double,double) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CliqueGraph___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  gum::CliqueGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_clique(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_separator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CliqueGraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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_MeekRules(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MeekRules *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_MeekRules", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (gum::MeekRules *)new gum::MeekRules();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MeekRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_MeekRules_propagate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MeekRules *arg1 = 0 ;
  gum::MixedGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::MixedGraph result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MeekRules_propagate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MeekRules, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeekRules_propagate" "', argument " "1"" of type '" "gum::MeekRules *""'"); 
  }
  arg1 = reinterpret_cast< gum::MeekRules * >(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 '" "MeekRules_propagate" "', argument " "2"" of type '" "gum::MixedGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MeekRules_propagate" "', argument " "2"" of type '" "gum::MixedGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MixedGraph * >(argp2);
  {
    try {
      result = (arg1)->propagate((gum::MixedGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::MixedGraph(result)), SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeekRules_propagateToCPDAG(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MeekRules *arg1 = 0 ;
  gum::MixedGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::PDAG result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MeekRules_propagateToCPDAG", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MeekRules, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeekRules_propagateToCPDAG" "', argument " "1"" of type '" "gum::MeekRules *""'"); 
  }
  arg1 = reinterpret_cast< gum::MeekRules * >(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 '" "MeekRules_propagateToCPDAG" "', argument " "2"" of type '" "gum::MixedGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MeekRules_propagateToCPDAG" "', argument " "2"" of type '" "gum::MixedGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MixedGraph * >(argp2);
  {
    try {
      result = (arg1)->propagateToCPDAG((gum::MixedGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::PDAG(result)), SWIGTYPE_p_gum__PDAG, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeekRules_propagateToDAG(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MeekRules *arg1 = 0 ;
  gum::MixedGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::DAG result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MeekRules_propagateToDAG", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MeekRules, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeekRules_propagateToDAG" "', argument " "1"" of type '" "gum::MeekRules *""'"); 
  }
  arg1 = reinterpret_cast< gum::MeekRules * >(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 '" "MeekRules_propagateToDAG" "', argument " "2"" of type '" "gum::MixedGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MeekRules_propagateToDAG" "', argument " "2"" of type '" "gum::MixedGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MixedGraph * >(argp2);
  {
    try {
      result = (arg1)->propagateToDAG((gum::MixedGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::DAG(result)), SWIGTYPE_p_gum__DAG, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeekRules_choices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MeekRules *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MeekRules, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeekRules_choices" "', argument " "1"" of type '" "gum::MeekRules const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MeekRules * >(argp1);
  {
    try {
      result = (PyObject *)gum_MeekRules_choices((gum::MeekRules const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Instantiation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::Instantiation *result = 0 ;
  
  (void)self;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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 *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 ;
  
  (void)self;
  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 *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 ;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_new_Instantiation__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_Instantiation__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimAdressable, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_Instantiation__SWIG_3(self, argc, argv);
  }
check_3:
  
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__MultiDimAdressable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_new_Instantiation__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Instantiation__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Instantiation__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Instantiation__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Idx result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_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_NullReferenceError, "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_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_erase" "', 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_erase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Instantiation_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_Instantiation_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Instantiation_erase", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Instantiation_erase__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Instantiation_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Instantiation_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Instantiation::erase(gum::DiscreteVariable const &)\n"
    "    gum::Instantiation::erase(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Instantiation_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Idx result;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Idx result;
  
  (void)self;
  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_NullReferenceError, "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__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Idx result;
  
  (void)self;
  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);
  {
    std::string *ptr = (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_val" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Instantiation_val" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::Instantiation const *)arg1)->val((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_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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Instantiation_val__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_Instantiation_val__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Instantiation_val__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::Instantiation::val(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Instantiation_variable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Instantiation_variable__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Instantiation_variable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Instantiation_chgVal__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_Instantiation_chgVal__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    return _wrap_Instantiation_chgVal__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Instantiation_chgVal__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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);
  {
    std::string *ptr = (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_contains" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Instantiation_contains" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)((gum::Instantiation const *)arg1)->contains((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_Instantiation_contains__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Instantiation_contains__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_gum__DiscreteVariable, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Instantiation_contains__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Instantiation_contains__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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(std::string const &) const\n"
    "    gum::Instantiation::contains(gum::DiscreteVariable const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Instantiation_variablesSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Sequence< gum::DiscreteVariable const * > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Instantiation___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Instantiation *result = 0 ;
  
  (void)self;
  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 +=(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Instantiation *result = 0 ;
  
  (void)self;
  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 -=(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Idx result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Sequence< gum::DiscreteVariable const * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      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) goto check_1;
    return _wrap_Instantiation_reorder__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Instantiation_reorder__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_setMutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_setMutable" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      gum_Instantiation_setMutable(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_isMutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_isMutable" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      result = (bool)gum_Instantiation_isMutable(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_todict__SWIG_0(PyObject *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 ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_Instantiation_todict__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Instantiation_todict__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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__cppfromdict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Instantiation__cppfromdict", 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__cppfromdict" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_Instantiation__cppfromdict(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 = NULL;
  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__static_list_end_safe__set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable _static_list_end_safe_ is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var__static_list_end_safe__get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&gum::_static_list_end_safe_), SWIGTYPE_p_gum__ListConstIteratorSafeT_Debug_t,  0 );
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var__static_list_end__get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&gum::_static_list_end_), SWIGTYPE_p_gum__ListConstIteratorT_Debug_t,  0 );
  return pyobj;
}


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_GraphicalModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GraphicalModel" "', argument " "1"" of type '" "gum::GraphicalModel *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_property(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "GraphicalModel_property", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_property" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GraphicalModel_property" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_property" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::string *) &((gum::GraphicalModel 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_GraphicalModel_propertyWithDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 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 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "GraphicalModel_propertyWithDefault", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_propertyWithDefault" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GraphicalModel_propertyWithDefault" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_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 '" "GraphicalModel_propertyWithDefault" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_propertyWithDefault" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (std::string *) &((gum::GraphicalModel 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_GraphicalModel_setProperty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "GraphicalModel_setProperty", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_setProperty" "', argument " "1"" of type '" "gum::GraphicalModel *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GraphicalModel_setProperty" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_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 '" "GraphicalModel_setProperty" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_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_GraphicalModel_properties(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_properties" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    try {
      result = ((gum::GraphicalModel const *)arg1)->properties();
    } 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_GraphicalModel_variableNodeMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VariableNodeMap *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_variableNodeMap" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    try {
      result = (gum::VariableNodeMap *) &((gum::GraphicalModel 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_GraphicalModel_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_size" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    try {
      result = ((gum::GraphicalModel 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_GraphicalModel_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_empty" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    try {
      result = (bool)((gum::GraphicalModel const *)arg1)->empty();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_exists__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_exists" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GraphicalModel_exists" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)((gum::GraphicalModel const *)arg1)->exists(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_exists__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_exists" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GraphicalModel_exists" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_exists" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)((gum::GraphicalModel const *)arg1)->exists((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_GraphicalModel_exists(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GraphicalModel_exists", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_GraphicalModel_exists__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_GraphicalModel_exists__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GraphicalModel_exists'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GraphicalModel::exists(gum::NodeId) const\n"
    "    gum::GraphicalModel::exists(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_names__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  std::vector< gum::NodeId,std::allocator< gum::NodeId > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_names" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(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 '" "GraphicalModel_names" "', argument " "2"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_names" "', 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 = ((gum::GraphicalModel const *)arg1)->names((std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)*arg2);
    } 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_GraphicalModel_names__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_names" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(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 '" "GraphicalModel_names" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_names" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeSet * >(argp2);
  {
    try {
      result = ((gum::GraphicalModel const *)arg1)->names((gum::NodeSet const &)*arg2);
    } 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_GraphicalModel_names(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GraphicalModel_names", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      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) goto check_1;
    return _wrap_GraphicalModel_names__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_GraphicalModel_names__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GraphicalModel_names'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GraphicalModel::names(std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &) const\n"
    "    gum::GraphicalModel::names(gum::NodeSet const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_ids(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::vector< std::size_t,std::allocator< std::size_t > > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "GraphicalModel_ids", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_ids" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(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 '" "GraphicalModel_ids" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_ids" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::GraphicalModel const *)arg1)->ids((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_nodeset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "GraphicalModel_nodeset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_nodeset" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(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 '" "GraphicalModel_nodeset" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_nodeset" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::GraphicalModel const *)arg1)->nodeset((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_variables__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< gum::Set< gum::DiscreteVariable const * > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_variables" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(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 '" "GraphicalModel_variables" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_variables" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::GraphicalModel const *)arg1)->variables((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::VariableSet(result)), SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_variables__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SwigValueWrapper< gum::Set< gum::DiscreteVariable const * > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_variables" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(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 '" "GraphicalModel_variables" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_variables" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeSet * >(argp2);
  {
    try {
      result = ((gum::GraphicalModel const *)arg1)->variables((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::VariableSet(result)), SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_variables(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GraphicalModel_variables", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      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) goto check_1;
    return _wrap_GraphicalModel_variables__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_GraphicalModel_variables__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GraphicalModel_variables'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GraphicalModel::variables(std::vector< std::string,std::allocator< std::string > > const &) const\n"
    "    gum::GraphicalModel::variables(gum::NodeSet const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeGraphPart *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_nodes" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    try {
      result = (gum::NodeGraphPart *) &((gum::GraphicalModel 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_GraphicalModel_completeInstantiation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Instantiation result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_completeInstantiation" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    try {
      result = ((gum::GraphicalModel const *)arg1)->completeInstantiation();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Instantiation(result)), SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_variable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "GraphicalModel_variable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_variable" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GraphicalModel_variable" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::GraphicalModel const *)arg1)->variable(SWIG_STD_MOVE(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_GraphicalModel_nodeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "GraphicalModel_nodeId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_nodeId" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(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 '" "GraphicalModel_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = ((gum::GraphicalModel 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_GraphicalModel_idFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "GraphicalModel_idFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_idFromName" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GraphicalModel_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::GraphicalModel 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_GraphicalModel_variableFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "GraphicalModel_variableFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_variableFromName" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GraphicalModel_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::GraphicalModel 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_GraphicalModel_log10DomainSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_log10DomainSize" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    try {
      result = (double)((gum::GraphicalModel const *)arg1)->log10DomainSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_isIndependent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  gum::NodeSet *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_isIndependent" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GraphicalModel_isIndependent" "', 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 '" "GraphicalModel_isIndependent" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GraphicalModel_isIndependent" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_isIndependent" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  arg4 = reinterpret_cast< gum::NodeSet * >(argp4);
  {
    try {
      result = (bool)((gum::GraphicalModel const *)arg1)->isIndependent(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(gum::NodeSet const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_isIndependent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  gum::NodeSet *arg3 = 0 ;
  gum::NodeSet *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_isIndependent" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(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 '" "GraphicalModel_isIndependent" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_isIndependent" "', 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 '" "GraphicalModel_isIndependent" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_isIndependent" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GraphicalModel_isIndependent" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_isIndependent" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  arg4 = reinterpret_cast< gum::NodeSet * >(argp4);
  {
    try {
      result = (bool)((gum::GraphicalModel const *)arg1)->isIndependent((gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3,(gum::NodeSet const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_isIndependent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GraphicalModel_isIndependent", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    {
      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) goto check_1;
    {
      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) goto check_1;
    PyObject *retobj = _wrap_GraphicalModel_isIndependent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_GraphicalModel_isIndependent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GraphicalModel_isIndependent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GraphicalModel::isIndependent(gum::NodeId,gum::NodeId,gum::NodeSet const &) const\n"
    "    gum::GraphicalModel::isIndependent(gum::NodeSet const &,gum::NodeSet const &,gum::NodeSet const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_family__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_family" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GraphicalModel_family" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::GraphicalModel const *)arg1)->family(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_family__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_family" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GraphicalModel_family" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GraphicalModel_family" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::GraphicalModel const *)arg1)->family((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_family(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GraphicalModel_family", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_GraphicalModel_family__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_GraphicalModel_family__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GraphicalModel_family'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GraphicalModel::family(gum::NodeId const) const\n"
    "    gum::GraphicalModel::family(std::string const &) const\n");
  return 0;
}


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

SWIGINTERN PyObject *_wrap_delete_DAGmodel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_dag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DAG *result = 0 ;
  
  (void)self;
  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_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeGraphPart *result = 0 ;
  
  (void)self;
  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_exists__SWIG_0(PyObject *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 ;
  bool result;
  
  (void)self;
  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_exists" "', 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_exists" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)((gum::DAGmodel const *)arg1)->exists(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_exists__SWIG_1(PyObject *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 ;
  bool result;
  
  (void)self;
  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_exists" "', 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_exists" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_exists" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)((gum::DAGmodel const *)arg1)->exists((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_DAGmodel_exists(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAGmodel_exists", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_DAGmodel_exists__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_DAGmodel_exists__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAGmodel_exists'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAGmodel::exists(gum::NodeId) const\n"
    "    gum::DAGmodel::exists(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAGmodel_arcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::ArcSet *result = 0 ;
  
  (void)self;
  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_existsArc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 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 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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_existsArc" "', 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_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 '" "DAGmodel_existsArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)((gum::DAGmodel const *)arg1)->existsArc(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_existsArc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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_existsArc" "', 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_existsArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_existsArc" "', 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_existsArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_existsArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (bool)((gum::DAGmodel const *)arg1)->existsArc((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(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_existsArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAGmodel_existsArc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_DAGmodel_existsArc__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_DAGmodel_existsArc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAGmodel_existsArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAGmodel::existsArc(gum::NodeId const,gum::NodeId const) const\n"
    "    gum::DAGmodel::existsArc(std::string const &,std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAGmodel_parents__SWIG_0(PyObject *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::NodeSet *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *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::NodeSet *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  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);
  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 '" "DAGmodel_parents" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_parents" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeSet * >(argp2);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->parents((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_parents__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  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::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 '" "DAGmodel_parents" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_parents" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->parents((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  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 = 0;
    {
      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) goto check_1;
    return _wrap_DAGmodel_parents__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_DAGmodel_parents__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_DAGmodel_parents__SWIG_1(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_DAGmodel_parents__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::DAGmodel::parents(gum::NodeSet const &) const\n"
    "    gum::DAGmodel::parents(std::vector< std::string,std::allocator< std::string > > const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAGmodel_family__SWIG_0(PyObject *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 ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  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_family" "', 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_family" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->family(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_family__SWIG_1(PyObject *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 ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  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_family" "', 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_family" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_family" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->family((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_family(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAGmodel_family", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_DAGmodel_family__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_DAGmodel_family__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAGmodel_family'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAGmodel::family(gum::NodeId const) const\n"
    "    gum::DAGmodel::family(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAGmodel_children__SWIG_0(PyObject *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::NodeSet *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *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::NodeSet *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  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);
  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 '" "DAGmodel_children" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_children" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeSet * >(argp2);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->children((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_children__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  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::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 '" "DAGmodel_children" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_children" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->children((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  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 = 0;
    {
      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) goto check_1;
    return _wrap_DAGmodel_children__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_DAGmodel_children__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_DAGmodel_children__SWIG_1(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_DAGmodel_children__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::DAGmodel::children(gum::NodeSet const &) const\n"
    "    gum::DAGmodel::children(std::vector< std::string,std::allocator< std::string > > const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAGmodel_descendants__SWIG_0(PyObject *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 ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  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_descendants" "', 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_descendants" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->descendants(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_descendants__SWIG_1(PyObject *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 ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  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_descendants" "', 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_descendants" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_descendants" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->descendants((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_descendants(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAGmodel_descendants", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_DAGmodel_descendants__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_DAGmodel_descendants__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAGmodel_descendants'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAGmodel::descendants(gum::NodeId const) const\n"
    "    gum::DAGmodel::descendants(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAGmodel_ancestors__SWIG_0(PyObject *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 ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  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_ancestors" "', 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_ancestors" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->ancestors(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_ancestors__SWIG_1(PyObject *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 ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  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_ancestors" "', 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_ancestors" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_ancestors" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->ancestors((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_ancestors(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAGmodel_ancestors", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_DAGmodel_ancestors__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_DAGmodel_ancestors__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAGmodel_ancestors'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAGmodel::ancestors(gum::NodeId const) const\n"
    "    gum::DAGmodel::ancestors(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAGmodel_moralizedAncestralGraph__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::UndiGraph result;
  
  (void)self;
  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_moralizedAncestralGraph" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(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 '" "DAGmodel_moralizedAncestralGraph" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_moralizedAncestralGraph" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeSet * >(argp2);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->moralizedAncestralGraph((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_moralizedAncestralGraph__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::UndiGraph result;
  
  (void)self;
  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_moralizedAncestralGraph" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(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 '" "DAGmodel_moralizedAncestralGraph" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_moralizedAncestralGraph" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->moralizedAncestralGraph((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_moralizedAncestralGraph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAGmodel_moralizedAncestralGraph", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      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) goto check_1;
    return _wrap_DAGmodel_moralizedAncestralGraph__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_DAGmodel_moralizedAncestralGraph__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAGmodel_moralizedAncestralGraph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAGmodel::moralizedAncestralGraph(gum::NodeSet const &) const\n"
    "    gum::DAGmodel::moralizedAncestralGraph(std::vector< std::string,std::allocator< std::string > > const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAGmodel_isIndependent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  gum::NodeSet *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) 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_isIndependent" "', 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_isIndependent" "', 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 '" "DAGmodel_isIndependent" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DAGmodel_isIndependent" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_isIndependent" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  arg4 = reinterpret_cast< gum::NodeSet * >(argp4);
  {
    try {
      result = (bool)((gum::DAGmodel const *)arg1)->isIndependent(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(gum::NodeSet const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_isIndependent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  gum::NodeSet *arg3 = 0 ;
  gum::NodeSet *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) 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_isIndependent" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(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 '" "DAGmodel_isIndependent" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_isIndependent" "', 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 '" "DAGmodel_isIndependent" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_isIndependent" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DAGmodel_isIndependent" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_isIndependent" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  arg4 = reinterpret_cast< gum::NodeSet * >(argp4);
  {
    try {
      result = (bool)((gum::DAGmodel const *)arg1)->isIndependent((gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3,(gum::NodeSet const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_isIndependent__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 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 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) 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_isIndependent" "', 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_isIndependent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_isIndependent" "', 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_isIndependent" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_isIndependent" "', 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 '" "DAGmodel_isIndependent" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_isIndependent" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (bool)((gum::DAGmodel const *)arg1)->isIndependent((std::string const &)*arg2,(std::string const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(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_DAGmodel_isIndependent__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< std::string,std::allocator< 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 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) 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_isIndependent" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(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 '" "DAGmodel_isIndependent" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_isIndependent" "', 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 '" "DAGmodel_isIndependent" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_isIndependent" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< 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 '" "DAGmodel_isIndependent" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_isIndependent" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (bool)((gum::DAGmodel const *)arg1)->isIndependent((std::vector< std::string,std::allocator< std::string > > const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(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_DAGmodel_isIndependent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAGmodel_isIndependent", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    {
      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) goto check_1;
    {
      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) goto check_1;
    {
      int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_DAGmodel_isIndependent__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_DAGmodel_isIndependent__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_DAGmodel_isIndependent__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_DAGmodel_isIndependent__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAGmodel_isIndependent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAGmodel::isIndependent(gum::NodeId,gum::NodeId,gum::NodeSet const &) const\n"
    "    gum::DAGmodel::isIndependent(gum::NodeSet const &,gum::NodeSet const &,gum::NodeSet const &) const\n"
    "    gum::DAGmodel::isIndependent(std::string const &,std::string const &,std::vector< std::string,std::allocator< std::string > > const &) const\n"
    "    gum::DAGmodel::isIndependent(std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAGmodel_moralGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::UndiGraph result;
  
  (void)self;
  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_moralGraph" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->moralGraph();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_topologicalOrder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::Sequence< std::size_t > > result;
  
  (void)self;
  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_topologicalOrder" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->topologicalOrder();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    PyObject *q=PyList_New(0);
    
    PyObject *pyval;
    for(auto i : static_cast<gum::Sequence<gum::NodeId>>(result)) {
      pyval=PyInt_FromLong(i);
      PyList_Append(q,pyval);
      Py_DecRef(pyval);
    }
    resultobj=q;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_hasSameStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  gum::DAGmodel *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *_wrap_DAGmodel_minimalCondSet__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 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;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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_minimalCondSet" "', 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_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 '" "DAGmodel_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->minimalCondSet(SWIG_STD_MOVE(arg2),(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_minimalCondSet__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 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;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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_minimalCondSet" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(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 '" "DAGmodel_minimalCondSet" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_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 '" "DAGmodel_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->minimalCondSet((gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_minimalCondSet__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 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 ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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_minimalCondSet" "', 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_minimalCondSet" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_minimalCondSet" "', 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 '" "DAGmodel_minimalCondSet" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_minimalCondSet" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->minimalCondSet((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_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_DAGmodel_minimalCondSet__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 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 ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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_minimalCondSet" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(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 '" "DAGmodel_minimalCondSet" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_minimalCondSet" "', 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 '" "DAGmodel_minimalCondSet" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DAGmodel_minimalCondSet" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->minimalCondSet((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::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_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_DAGmodel_minimalCondSet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAGmodel_minimalCondSet", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      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) goto check_1;
    {
      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) goto check_1;
    return _wrap_DAGmodel_minimalCondSet__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      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) goto check_2;
    return _wrap_DAGmodel_minimalCondSet__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_DAGmodel_minimalCondSet__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_DAGmodel_minimalCondSet__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAGmodel_minimalCondSet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAGmodel::minimalCondSet(gum::NodeId,gum::NodeSet const &) const\n"
    "    gum::DAGmodel::minimalCondSet(gum::NodeSet const &,gum::NodeSet const &) const\n"
    "    gum::DAGmodel::minimalCondSet(std::string const &,std::vector< std::string,std::allocator< std::string > > const &) const\n"
    "    gum::DAGmodel::minimalCondSet(std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &) const\n");
  return 0;
}


SWIGINTERN PyObject *DAGmodel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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_delete_UGmodel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UGmodel" "', argument " "1"" of type '" "gum::UGmodel *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UGmodel_graph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::UndiGraph *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_graph" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  {
    try {
      result = (gum::UndiGraph *) &((gum::UGmodel const *)arg1)->graph();
    } 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_UGmodel_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_size" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  {
    try {
      result = ((gum::UGmodel 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_UGmodel_sizeEdges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_sizeEdges" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  {
    try {
      result = ((gum::UGmodel 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_UGmodel_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeGraphPart *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_nodes" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  {
    try {
      result = (gum::NodeGraphPart *) &((gum::UGmodel 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_UGmodel_exists__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_exists" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UGmodel_exists" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)((gum::UGmodel const *)arg1)->exists(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UGmodel_exists__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_exists" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UGmodel_exists" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_exists" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)((gum::UGmodel const *)arg1)->exists((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_UGmodel_exists(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UGmodel_exists", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_UGmodel_exists__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_UGmodel_exists__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UGmodel_exists'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UGmodel::exists(gum::NodeId) const\n"
    "    gum::UGmodel::exists(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UGmodel_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::EdgeSet *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_edges" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  {
    try {
      result = (gum::EdgeSet *) &((gum::UGmodel const *)arg1)->edges();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SetT_gum__Edge_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UGmodel_existsEdge__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 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 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_existsEdge" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UGmodel_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 '" "UGmodel_existsEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)((gum::UGmodel const *)arg1)->existsEdge(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UGmodel_existsEdge__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_existsEdge" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UGmodel_existsEdge" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_existsEdge" "', 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 '" "UGmodel_existsEdge" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_existsEdge" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (bool)((gum::UGmodel const *)arg1)->existsEdge((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(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_UGmodel_existsEdge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UGmodel_existsEdge", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_UGmodel_existsEdge__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_UGmodel_existsEdge__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UGmodel_existsEdge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UGmodel::existsEdge(gum::NodeId const,gum::NodeId const) const\n"
    "    gum::UGmodel::existsEdge(std::string const &,std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UGmodel_neighbours__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::NodeSet *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_neighbours" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UGmodel_neighbours" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::NodeSet *) &((gum::UGmodel const *)arg1)->neighbours(SWIG_STD_MOVE(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_UGmodel_neighbours__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::NodeSet *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_neighbours" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UGmodel_neighbours" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_neighbours" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::NodeSet *) &((gum::UGmodel const *)arg1)->neighbours((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_UGmodel_neighbours(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UGmodel_neighbours", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_UGmodel_neighbours__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_UGmodel_neighbours__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UGmodel_neighbours'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UGmodel::neighbours(gum::NodeId const) const\n"
    "    gum::UGmodel::neighbours(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UGmodel_isIndependent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  gum::NodeSet *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_isIndependent" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UGmodel_isIndependent" "', 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 '" "UGmodel_isIndependent" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UGmodel_isIndependent" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_isIndependent" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  arg4 = reinterpret_cast< gum::NodeSet * >(argp4);
  {
    try {
      result = (bool)((gum::UGmodel const *)arg1)->isIndependent(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(gum::NodeSet const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UGmodel_isIndependent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  gum::NodeSet *arg3 = 0 ;
  gum::NodeSet *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_isIndependent" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(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 '" "UGmodel_isIndependent" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_isIndependent" "', 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 '" "UGmodel_isIndependent" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_isIndependent" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UGmodel_isIndependent" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_isIndependent" "', argument " "4"" of type '" "gum::NodeSet const &""'"); 
  }
  arg4 = reinterpret_cast< gum::NodeSet * >(argp4);
  {
    try {
      result = (bool)((gum::UGmodel const *)arg1)->isIndependent((gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3,(gum::NodeSet const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UGmodel_isIndependent__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 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 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_isIndependent" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UGmodel_isIndependent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_isIndependent" "', 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 '" "UGmodel_isIndependent" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_isIndependent" "', 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 '" "UGmodel_isIndependent" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_isIndependent" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (bool)((gum::UGmodel const *)arg1)->isIndependent((std::string const &)*arg2,(std::string const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(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_UGmodel_isIndependent__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< std::string,std::allocator< 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 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_isIndependent" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(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 '" "UGmodel_isIndependent" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_isIndependent" "', 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 '" "UGmodel_isIndependent" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_isIndependent" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< 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 '" "UGmodel_isIndependent" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_isIndependent" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (bool)((gum::UGmodel const *)arg1)->isIndependent((std::vector< std::string,std::allocator< std::string > > const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(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_UGmodel_isIndependent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UGmodel_isIndependent", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    {
      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) goto check_1;
    {
      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) goto check_1;
    {
      int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_UGmodel_isIndependent__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_UGmodel_isIndependent__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_UGmodel_isIndependent__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_UGmodel_isIndependent__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UGmodel_isIndependent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UGmodel::isIndependent(gum::NodeId,gum::NodeId,gum::NodeSet const &) const\n"
    "    gum::UGmodel::isIndependent(gum::NodeSet const &,gum::NodeSet const &,gum::NodeSet const &) const\n"
    "    gum::UGmodel::isIndependent(std::string const &,std::string const &,std::vector< std::string,std::allocator< std::string > > const &) const\n"
    "    gum::UGmodel::isIndependent(std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UGmodel_hasSameStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  gum::UGmodel *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UGmodel_hasSameStructure", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_hasSameStructure" "', argument " "1"" of type '" "gum::UGmodel *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__UGmodel,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UGmodel_hasSameStructure" "', argument " "2"" of type '" "gum::UGmodel const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_hasSameStructure" "', argument " "2"" of type '" "gum::UGmodel const &""'"); 
  }
  arg2 = reinterpret_cast< gum::UGmodel * >(argp2);
  {
    try {
      result = (bool)(arg1)->hasSameStructure((gum::UGmodel const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UGmodel_family__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_family" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UGmodel_family" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::UGmodel const *)arg1)->family(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UGmodel_family__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UGmodel *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_family" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UGmodel_family" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UGmodel_family" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::UGmodel const *)arg1)->family((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UGmodel_family(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UGmodel_family", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_UGmodel_family__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_UGmodel_family__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UGmodel_family'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UGmodel::family(gum::NodeId const) const\n"
    "    gum::UGmodel::family(std::string const &) const\n");
  return 0;
}


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

SWIGINTERN PyObject *_wrap_new_ApproximationScheme__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  gum::ApproximationScheme *result = 0 ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *result = 0 ;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_new_ApproximationScheme__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_ApproximationScheme__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_maxIter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_periodSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration::ApproximationSchemeSTATE result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = (bool)((gum::ApproximationScheme const *)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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_ApproximationScheme_updateApproximationScheme__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_ApproximationScheme_updateApproximationScheme__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = ((gum::ApproximationScheme const *)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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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 = NULL;
  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_fastVariable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::Size arg2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::unique_ptr< gum::DiscreteVariable > result;
  
  (void)self;
  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 '" "fastVariable" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fastVariable" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR fastVariable< double >(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj((&result)->release(), SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_OWN |  0 );
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fastVariable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string *arg2 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::unique_ptr< gum::DiscreteVariable > result;
  
  (void)self;
  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 '" "fastVariable" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete 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 '" "fastVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fastVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR fastVariable< double >(SWIG_STD_MOVE(arg1),(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj((&result)->release(), SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_OWN |  0 );
  
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fastVariable__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::unique_ptr< gum::DiscreteVariable > result;
  
  (void)self;
  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 '" "fastVariable" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR fastVariable< double >(SWIG_STD_MOVE(arg1));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj((&result)->release(), SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_OWN |  0 );
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fastVariable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fastVariable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_fastVariable__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_fastVariable__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_fastVariable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fastVariable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::fastVariable< double >(std::string,gum::Size)\n"
    "    gum::fastVariable< double >(std::string,std::string const &)\n"
    "    gum::fastVariable< double >(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_randomDistribution(PyObject *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;
  
  (void)self;
  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 >(SWIG_STD_MOVE(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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *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 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  gum::DiscretizedVariable< double > *result = 0 ;
  
  (void)self;
  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_DiscretizedVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "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_NullReferenceError, "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_NullReferenceError, "invalid null reference " "in method '" "new_DiscretizedVariable" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DiscretizedVariable" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    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,arg4);
    } 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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_NullReferenceError, "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_3(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DiscretizedVariable", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DiscretizedVariable__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DiscretizedVariable__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DiscretizedVariable__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_DiscretizedVariable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 &,bool)\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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DiscretizedVariable< double > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VarType result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 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 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DiscretizedVariable_draw", 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_draw" "', 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_draw" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = (double)((gum::DiscretizedVariable< double > const *)arg1)->draw(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_index__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Idx result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) 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_NullReferenceError, "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_index__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::Idx result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) 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);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscretizedVariable_index" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = ((gum::DiscretizedVariable< double > const *)arg1)->index(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_index(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DiscretizedVariable_index", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_DiscretizedVariable_index__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_DiscretizedVariable_index__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiscretizedVariable_index'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DiscretizedVariable< double >::index(std::string const &) const\n"
    "    gum::DiscretizedVariable< double >::index(double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_domainSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_stype(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_stype" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  {
    try {
      result = ((gum::DiscretizedVariable< double > const *)arg1)->stype();
    } 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_ticks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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_closestIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DiscretizedVariable_closestIndex", 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_closestIndex" "', 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_closestIndex" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = ((gum::DiscretizedVariable< double > const *)arg1)->closestIndex(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_toFast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_toFast" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  {
    try {
      result = ((gum::DiscretizedVariable< double > const *)arg1)->toFast();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 = NULL;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 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] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MultiDimContainer_populate", 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_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_NullReferenceError, "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_copyFrom__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  gum::MultiDimContainer< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_MultiDimContainer_copyFrom__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_MultiDimContainer_copyFrom__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 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] ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::MultiDimImplementation< double > *result = 0 ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::MultiDimImplementation< double > *result = 0 ;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_MultiDimContainer_content__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_MultiDimContainer_content__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::MultiDimAdressable *result = 0 ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::MultiDimAdressable *result = 0 ;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_MultiDimContainer_getMasterRef__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_MultiDimContainer_getMasterRef__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  gum::MultiDimContainer< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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_toString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::string result;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_MultiDimContainer_toString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_MultiDimContainer_toString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  gum::MultiDimContainer< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  gum::MultiDimContainer< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_apply(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  std::function< double (double) > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_reduce(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_MultiDimContainer_endMultipleChanges__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_MultiDimContainer_endMultipleChanges__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 = NULL;
  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_Tensor_deterministicTensor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) 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 '" "Tensor_deterministicTensor" "', argument " "1"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_deterministicTensor" "', 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 '" "Tensor_deterministicTensor" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = gum::Tensor< double >::SWIGTEMPLATEDISAMBIGUATOR deterministicTensor((gum::DiscreteVariable const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_deterministicTensor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) 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 '" "Tensor_deterministicTensor" "', argument " "1"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_deterministicTensor" "', 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 '" "Tensor_deterministicTensor" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_deterministicTensor" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum::Tensor< double >::SWIGTEMPLATEDISAMBIGUATOR deterministicTensor((gum::DiscreteVariable const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_deterministicTensor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_deterministicTensor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Tensor_deterministicTensor__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_deterministicTensor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_deterministicTensor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::deterministicTensor(gum::DiscreteVariable const &,gum::Idx)\n"
    "    gum::Tensor< double >::deterministicTensor(gum::DiscreteVariable const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_uniformTensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > result;
  
  (void)self;
  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 '" "Tensor_uniformTensor" "', argument " "1"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_uniformTensor" "', argument " "1"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = gum::Tensor< double >::SWIGTEMPLATEDISAMBIGUATOR uniformTensor((gum::DiscreteVariable const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_Tensor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_gum__DiscreteVariable_const_p_std__allocatorT_gum__DiscreteVariable_const_p_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Tensor" "', argument " "1"" of type '" "std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Tensor" "', argument " "1"" of type '" "std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > const &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > * >(argp1);
  {
    try {
      result = (gum::Tensor< double > *)new gum::Tensor< double >((std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Tensor__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimImplementation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_Tensor" "', argument " "1"" of type '" "gum::MultiDimImplementation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimImplementation< double > * >(argp1);
  {
    try {
      result = (gum::Tensor< double > *)new gum::Tensor< double >(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Tensor__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimImplementation< double > *arg1 = 0 ;
  gum::MultiDimContainer< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_Tensor" "', 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_Tensor" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Tensor" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp2);
  {
    try {
      result = (gum::Tensor< double > *)new gum::Tensor< double >(arg1,(gum::MultiDimContainer< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_Tensor__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< gum::Tensor< double > > rvrdeleter1 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Tensor" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "gum::Tensor< double > &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Tensor" "', argument " "1"" of type '" "gum::Tensor< double > &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Tensor" "', argument " "1"" of type '" "gum::Tensor< double > &&""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    try {
      result = (gum::Tensor< double > *)new gum::Tensor< double >((gum::Tensor< double > &&)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Tensor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Tensor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_Tensor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 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) goto check_2;
    return _wrap_new_Tensor__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_Tensor__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_new_Tensor__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Tensor__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Tensor__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Tensor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::Tensor()\n"
    "    gum::Tensor< double >::Tensor(std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > const &)\n"
    "    gum::Tensor< double >::Tensor(gum::MultiDimImplementation< double > *)\n"
    "    gum::Tensor< double >::Tensor(gum::MultiDimImplementation< double > *,gum::MultiDimContainer< double > const &)\n"
    "    gum::Tensor< double >::Tensor(gum::Tensor< double > const &)\n"
    "    gum::Tensor< double >::Tensor(gum::Tensor< double > &&)\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_Tensor_random(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_random" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->random();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_randomDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_randomDistribution" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->randomDistribution();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_randomCPT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_randomCPT" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->randomCPT();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_noising(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_noising", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_noising" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor_noising" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->noising(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_sumOut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::VariableSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_sumOut" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor_sumOut" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_sumOut" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::VariableSet * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->sumOut((gum::VariableSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_sumIn__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::VariableSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_sumIn" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor_sumIn" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_sumIn" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::VariableSet * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->sumIn((gum::VariableSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_prodOut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::VariableSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_prodOut" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor_prodOut" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_prodOut" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::VariableSet * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->prodOut((gum::VariableSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_prodIn__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::VariableSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_prodIn" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor_prodIn" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_prodIn" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::VariableSet * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->prodIn((gum::VariableSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_minOut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::VariableSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_minOut" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor_minOut" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_minOut" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::VariableSet * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->minOut((gum::VariableSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_minIn__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::VariableSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_minIn" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor_minIn" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_minIn" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::VariableSet * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->minIn((gum::VariableSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_maxOut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::VariableSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_maxOut" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor_maxOut" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_maxOut" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::VariableSet * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->maxOut((gum::VariableSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_maxIn__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::VariableSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_maxIn" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor_maxIn" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_maxIn" "', argument " "2"" of type '" "gum::VariableSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::VariableSet * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->maxIn((gum::VariableSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_isNonZeroMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_isNonZeroMap" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->isNonZeroMap();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_sum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_sum" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (double)((gum::Tensor< double > const *)arg1)->sum();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_product(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_product" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (double)((gum::Tensor< double > const *)arg1)->product();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_max" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (double)((gum::Tensor< double > const *)arg1)->max();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_min" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (double)((gum::Tensor< double > const *)arg1)->min();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_maxNonOne(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_maxNonOne" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (double)((gum::Tensor< double > const *)arg1)->maxNonOne();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_minNonZero(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_minNonZero" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (double)((gum::Tensor< double > const *)arg1)->minNonZero();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_findAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< gum::Set< gum::Instantiation > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_findAll", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_findAll" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor_findAll" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->findAll(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySeqFromSetOfInstantiation(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_expectedValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  SwigValueWrapper< std::function< double (gum::Instantiation const &) > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_expectedValue" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__functionT_double_fgum__Instantiation_const_RF_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor_expectedValue" "', argument " "2"" of type '" "std::function< double (gum::Instantiation const &) >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_expectedValue" "', argument " "2"" of type '" "std::function< double (gum::Instantiation const &) >""'");
    } else {
      std::function< double (gum::Instantiation const &) > * temp = reinterpret_cast< std::function< double (gum::Instantiation const &) > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (double)((gum::Tensor< double > const *)arg1)->expectedValue(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_entropy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_entropy" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (double)((gum::Tensor< double > const *)arg1)->entropy();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_reorganize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_reorganize" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< 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 '" "Tensor_reorganize" "', argument " "2"" of type '" "std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_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::Tensor< 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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_reorganize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_reorganize" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< 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 '" "Tensor_reorganize" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_reorganize" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->reorganize((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_reorganize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_reorganize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      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) goto check_1;
    return _wrap_Tensor_reorganize__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_reorganize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_reorganize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::reorganize(std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > const &) const\n"
    "    gum::Tensor< double >::reorganize(std::vector< std::string,std::allocator< std::string > > const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_extract__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_extract" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< 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 '" "Tensor_extract" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_extract" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->extract((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_putFirst(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_putFirst", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_putFirst" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< 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 '" "Tensor_putFirst" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_putFirst" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->putFirst((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_fillWith__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_fillWith" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor_fillWith" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_fillWith" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->fillWith((gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_fillWith__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< 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::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_fillWith" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor_fillWith" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_fillWith" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< 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 '" "Tensor_fillWith" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_fillWith" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->fillWith((gum::Tensor< 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__TensorT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_fillWith__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_fillWith" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< 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 '" "Tensor_fillWith" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_fillWith" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< 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__TensorT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_fillWith__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_fillWith" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor_fillWith" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->fillWith((double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_fillWith(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_fillWith", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor_fillWith__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_Tensor_fillWith__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_fillWith__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Tensor_fillWith__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_fillWith'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::fillWith(gum::Tensor< double > const &) const\n"
    "    gum::Tensor< double >::fillWith(gum::Tensor< double > const &,std::vector< std::string,std::allocator< std::string > > const &) const\n"
    "    gum::Tensor< double >::fillWith(std::vector< double,std::allocator< double > > const &) const\n"
    "    gum::Tensor< double >::fillWith(double const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_abs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_abs" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->abs();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_sq(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_sq" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->sq();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_log2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_log2" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->log2();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_sgn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_sgn" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->sgn();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_new_abs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_new_abs" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->new_abs();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_new_sq(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_new_sq" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->new_sq();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_new_log2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_new_log2" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->new_log2();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_new_sgn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_new_sgn" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->new_sgn();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_normalize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_normalize" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->normalize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_KL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_KL", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_KL" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor_KL" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_KL" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = (double)((gum::Tensor< double > const *)arg1)->KL((gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_normalizeAsCPT__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Idx *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Idx temp2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_normalizeAsCPT" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor_normalizeAsCPT" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  temp2 = static_cast< gum::Idx >(val2);
  arg2 = &temp2;
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->normalizeAsCPT((gum::Idx const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_normalizeAsCPT__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_normalizeAsCPT" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->normalizeAsCPT();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_normalizeAsCPT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_normalizeAsCPT", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Tensor_normalizeAsCPT__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_normalizeAsCPT__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_normalizeAsCPT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::normalizeAsCPT(gum::Idx const &) const\n"
    "    gum::Tensor< double >::normalizeAsCPT() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_scale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_scale", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_scale" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor_scale" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->scale(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_translate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_translate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_translate" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor_translate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->translate(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_inverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_inverse" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Tensor< double > const *)arg1)->inverse();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Idx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_draw" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = ((gum::Tensor< 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_Tensor_memoryFootprint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_memoryFootprint" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->memoryFootprint();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor___add____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___add__" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor___add__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor___add__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->operator +((gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___add____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___add__" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor___add__" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->operator +((double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___add__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor___add__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor___add____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor___add____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___sub____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___sub__" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor___sub__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor___sub__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->operator -((gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___sub____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___sub__" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor___sub__" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->operator -((double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___sub__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor___sub__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor___sub____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor___sub____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___mul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___mul__" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor___mul__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor___mul__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->operator *((gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___mul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___mul__" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor___mul__" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->operator *((double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor___mul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor___mul____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor___mul____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___truediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___truediv__" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor___truediv__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor___truediv__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->operator /((gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___truediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___truediv__" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor___truediv__" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->operator /((double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___truediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor___truediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor___truediv____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor___truediv____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___iadd____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___iadd__" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor___iadd__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor___iadd__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->operator +=((gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor___iadd____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___iadd__" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor___iadd__" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->operator +=((double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor___iadd__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor___iadd__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor___iadd____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor___iadd____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor___iadd__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::operator +=(gum::Tensor< double > const &)\n"
    "    gum::Tensor< double >::operator +=(double const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___imul__" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor___imul__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor___imul__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->operator *=((gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___imul__" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor___imul__" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->operator *=((double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor___imul____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor___imul____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::operator *=(gum::Tensor< double > const &)\n"
    "    gum::Tensor< double >::operator *=(double const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor___isub____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___isub__" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor___isub__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor___isub__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->operator -=((gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor___isub____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___isub__" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor___isub__" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->operator -=((double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor___isub__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor___isub__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor___isub____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor___isub____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor___isub__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::operator -=(gum::Tensor< double > const &)\n"
    "    gum::Tensor< double >::operator -=(double const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor___itruediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___itruediv__" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor___itruediv__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor___itruediv__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->operator /=((gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor___itruediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___itruediv__" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->operator /=((double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor___itruediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor___itruediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor___itruediv____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor___itruediv____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor___itruediv__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::operator /=(gum::Tensor< double > const &)\n"
    "    gum::Tensor< double >::operator /=(double const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_isEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_isEvidence" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (bool)((gum::Tensor< double > const *)arg1)->isEvidence();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor___or__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor___or__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___or__" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor___or__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor___or__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->operator |((gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___and__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor___and__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___and__" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor___and__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor___and__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->operator &((gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___invert__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___invert__" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->operator ~();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor___eq____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___eq__" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor___eq__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor___eq__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = (bool)((gum::Tensor< double > const *)arg1)->operator ==((gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor_evEq(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_evEq", 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 '" "Tensor_evEq" "', argument " "1"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_evEq" "', argument " "1"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor_evEq" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = gum::Tensor< double >::SWIGTEMPLATEDISAMBIGUATOR evEq((gum::DiscreteVariable const &)*arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_evIn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_evIn", 3, 3, 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 '" "Tensor_evIn" "', argument " "1"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_evIn" "', argument " "1"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor_evIn" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Tensor_evIn" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = gum::Tensor< double >::SWIGTEMPLATEDISAMBIGUATOR evIn((gum::DiscreteVariable const &)*arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_evGt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_evGt", 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 '" "Tensor_evGt" "', argument " "1"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_evGt" "', argument " "1"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor_evGt" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = gum::Tensor< double >::SWIGTEMPLATEDISAMBIGUATOR evGt((gum::DiscreteVariable const &)*arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_evLt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_evLt", 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 '" "Tensor_evLt" "', argument " "1"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_evLt" "', argument " "1"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor_evLt" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = gum::Tensor< double >::SWIGTEMPLATEDISAMBIGUATOR evLt((gum::DiscreteVariable const &)*arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___repr__" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = gum_Tensor_Sl_double_Sg____repr__((gum::Tensor< 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_Tensor___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___str__" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = gum_Tensor_Sl_double_Sg____str__((gum::Tensor< 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_Tensor_expectedValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_expectedValue" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_Tensor_Sl_double_Sg__expectedValue__SWIG_1((gum::Tensor< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_expectedValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_expectedValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__functionT_double_fgum__Instantiation_const_RF_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor_expectedValue__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_expectedValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_expectedValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::expectedValue(std::function< double (gum::Instantiation const &) >) const\n"
    "    gum::Tensor< double >::expectedValue(PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_extract__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_extract" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Tensor_Sl_double_Sg__extract__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_extract(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_extract", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor_extract__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_extract__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_extract'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::extract(gum::Instantiation const &) const\n"
    "    gum::Tensor< double >::extract(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_sumOut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_sumOut" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Tensor_Sl_double_Sg__sumOut__SWIG_1((gum::Tensor< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_sumOut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_sumOut", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor_sumOut__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_sumOut__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_sumOut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::sumOut(gum::VariableSet const &) const\n"
    "    gum::Tensor< double >::sumOut(PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_prodOut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_prodOut" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Tensor_Sl_double_Sg__prodOut__SWIG_1((gum::Tensor< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_prodOut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_prodOut", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor_prodOut__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_prodOut__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_prodOut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::prodOut(gum::VariableSet const &) const\n"
    "    gum::Tensor< double >::prodOut(PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_maxOut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_maxOut" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Tensor_Sl_double_Sg__maxOut__SWIG_1((gum::Tensor< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_maxOut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_maxOut", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor_maxOut__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_maxOut__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_maxOut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::maxOut(gum::VariableSet const &) const\n"
    "    gum::Tensor< double >::maxOut(PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_minOut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_minOut" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Tensor_Sl_double_Sg__minOut__SWIG_1((gum::Tensor< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_minOut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_minOut", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor_minOut__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_minOut__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_minOut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::minOut(gum::VariableSet const &) const\n"
    "    gum::Tensor< double >::minOut(PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_sumIn__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_sumIn" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Tensor_Sl_double_Sg__sumIn__SWIG_1((gum::Tensor< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_sumIn(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_sumIn", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor_sumIn__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_sumIn__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_sumIn'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::sumIn(gum::VariableSet const &) const\n"
    "    gum::Tensor< double >::sumIn(PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_prodIn__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_prodIn" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Tensor_Sl_double_Sg__prodIn__SWIG_1((gum::Tensor< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_prodIn(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_prodIn", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor_prodIn__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_prodIn__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_prodIn'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::prodIn(gum::VariableSet const &) const\n"
    "    gum::Tensor< double >::prodIn(PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_maxIn__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_maxIn" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Tensor_Sl_double_Sg__maxIn__SWIG_1((gum::Tensor< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_maxIn(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_maxIn", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor_maxIn__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_maxIn__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_maxIn'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::maxIn(gum::VariableSet const &) const\n"
    "    gum::Tensor< double >::maxIn(PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_minIn__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_minIn" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Tensor_Sl_double_Sg__minIn__SWIG_1((gum::Tensor< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_minIn(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_minIn", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__SetT_gum__DiscreteVariable_const_p_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Tensor_minIn__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_minIn__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_minIn'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::minIn(gum::VariableSet const &) const\n"
    "    gum::Tensor< double >::minIn(PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_argmin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_argmin" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_Tensor_Sl_double_Sg__argmin(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_argmax(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_argmax" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_Tensor_Sl_double_Sg__argmax(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor___eq____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___eq__" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor___eq__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor___eq__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = (bool)gum_Tensor_Sl_double_Sg____eq____SWIG_1(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___eq__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor___eq__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor___eq____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor___eq____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor___ne__" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tensor___ne__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor___ne__" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = (bool)gum_Tensor_Sl_double_Sg____ne__(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Tensor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_get" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< 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 '" "Tensor_get" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_get" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      result = (double)gum_Tensor_Sl_double_Sg__get((gum::Tensor< 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_Tensor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_set" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< 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 '" "Tensor_set" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_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 '" "Tensor_set" "', argument " "3"" of type '" "double""'");
  } 
  temp3 = static_cast< double >(val3);
  arg3 = &temp3;
  {
    try {
      gum_Tensor_Sl_double_Sg__set((gum::Tensor< 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_Tensor_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_empty" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (bool)gum_Tensor_Sl_double_Sg__empty((gum::Tensor< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_pos(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_pos", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_pos" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< 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 '" "Tensor_pos" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_pos" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = gum_Tensor_Sl_double_Sg__pos((gum::Tensor< 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_Tensor_contains(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_contains", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_contains" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< 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 '" "Tensor_contains" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_contains" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (bool)gum_Tensor_Sl_double_Sg__contains((gum::Tensor< 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_Tensor_nbrDim__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Idx result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_nbrDim" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = gum_Tensor_Sl_double_Sg__nbrDim__SWIG_0((gum::Tensor< 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_Tensor_variable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_variable" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tensor_variable" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = (gum::DiscreteVariable *) &gum_Tensor_Sl_double_Sg__variable__SWIG_0((gum::Tensor< double > const *)arg1,SWIG_STD_MOVE(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_Tensor_variable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_variable" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< 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 '" "Tensor_variable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_variable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &gum_Tensor_Sl_double_Sg__variable__SWIG_1((gum::Tensor< 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_Tensor_variable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_variable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Tensor_variable__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Tensor_variable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_variable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::variable(gum::Idx) const\n"
    "    gum::Tensor< double >::variable(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Tensor_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_remove" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< 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 '" "Tensor_remove" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_remove" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      gum_Tensor_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_Tensor_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_add" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< 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 '" "Tensor_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Tensor_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      gum_Tensor_Sl_double_Sg__add(arg1,(gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_domainSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_domainSize" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = gum_Tensor_Sl_double_Sg__domainSize(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_nbrDim__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Size result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tensor_nbrDim" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = gum_Tensor_Sl_double_Sg__nbrDim__SWIG_1(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_nbrDim(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Tensor_nbrDim", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Tensor_nbrDim__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Tensor_nbrDim__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Tensor_nbrDim'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Tensor< double >::nbrDim() const\n"
    "    gum::Tensor< double >::nbrDim()\n");
  return 0;
}


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

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

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


SWIGINTERN PyObject *_wrap_new_PairMPE__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation arg1 ;
  double arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  std::pair< gum::Instantiation,double > *result = 0 ;
  
  (void)self;
  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_PairMPE" "', argument " "1"" of type '" "gum::Instantiation""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PairMPE" "', argument " "1"" of type '" "gum::Instantiation""'");
    } else {
      gum::Instantiation * temp = reinterpret_cast< gum::Instantiation * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PairMPE" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (std::pair< gum::Instantiation,double > *)new std::pair< gum::Instantiation,double >(SWIG_STD_MOVE(arg1),arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_gum__Instantiation_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PairMPE__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< gum::Instantiation,double > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::pair< gum::Instantiation,double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::pair< gum::Instantiation,double > *ptr = (std::pair< gum::Instantiation,double > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PairMPE" "', argument " "1"" of type '" "std::pair< gum::Instantiation,double > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PairMPE" "', argument " "1"" of type '" "std::pair< gum::Instantiation,double > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::pair< gum::Instantiation,double > *)new std::pair< gum::Instantiation,double >((std::pair< gum::Instantiation,double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_gum__Instantiation_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_PairMPE(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PairMPE", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_PairMPE__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_PairMPE__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_PairMPE__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PairMPE'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< gum::Instantiation,double >::pair()\n"
    "    std::pair< gum::Instantiation,double >::pair(gum::Instantiation,double)\n"
    "    std::pair< gum::Instantiation,double >::pair(std::pair< gum::Instantiation,double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PairMPE_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< gum::Instantiation,double > *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PairMPE_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_gum__Instantiation_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairMPE_first_set" "', argument " "1"" of type '" "std::pair< gum::Instantiation,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< gum::Instantiation,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 '" "PairMPE_first_set" "', argument " "2"" of type '" "gum::Instantiation *""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  if (arg1) (arg1)->first = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PairMPE_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< gum::Instantiation,double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Instantiation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_gum__Instantiation_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairMPE_first_get" "', argument " "1"" of type '" "std::pair< gum::Instantiation,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< gum::Instantiation,double > * >(argp1);
  result = (gum::Instantiation *)& ((arg1)->first);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PairMPE_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< gum::Instantiation,double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PairMPE_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_gum__Instantiation_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairMPE_second_set" "', argument " "1"" of type '" "std::pair< gum::Instantiation,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< gum::Instantiation,double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PairMPE_second_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->second = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PairMPE_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< gum::Instantiation,double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_gum__Instantiation_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairMPE_second_get" "', argument " "1"" of type '" "std::pair< gum::Instantiation,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< gum::Instantiation,double > * >(argp1);
  result = (double) ((arg1)->second);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


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


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

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

SWIGINTERN PyObject *_wrap_statsObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  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;
}


SWIGINTERN PyObject *_wrap_getNumberOfThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "getNumberOfThreads", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (unsigned int)gum::multithreading::getNumberOfThreads();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_getMaxNumberOfThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "getMaxNumberOfThreads", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (unsigned int)gum::multithreading::getMaxNumberOfThreads();
    } 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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "getNumberOfLogicalProcessors", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (unsigned int)gum::multithreading::getNumberOfLogicalProcessors();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PythonBNListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::VariableNodeMap *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  PythonBNListener *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = 0 ;
  void *arg2 = 0 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonBNListener_whenNodeDeleted(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = 0 ;
  void *arg2 = 0 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonBNListener_whenArcAdded(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = 0 ;
  void *arg2 = 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] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonBNListener_whenArcDeleted(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = 0 ;
  void *arg2 = 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] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonBNListener_setWhenArcAdded(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 = NULL;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonLoadListener *arg1 = 0 ;
  void *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonLoadListener *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonLoadListener *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonLoadListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< PythonLoadListener,std::allocator< PythonLoadListener > > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IApproximationSchemeConfiguration *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PythonApproximationListener *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonApproximationListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonApproximationListener *arg1 = 0 ;
  void *arg2 = 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] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg3),arg4,arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonApproximationListener_whenStop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonApproximationListener *arg1 = 0 ;
  void *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  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;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PythonApproximationListener_whenStop" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PythonApproximationListener_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_PythonApproximationListener_setWhenProgress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonApproximationListener *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonApproximationListener *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 = NULL;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonDatabaseGeneratorListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonDatabaseGeneratorListener *arg1 = 0 ;
  void *arg2 = 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] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg3),arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonDatabaseGeneratorListener_whenStop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonDatabaseGeneratorListener *arg1 = 0 ;
  void *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonDatabaseGeneratorListener *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PythonDatabaseGeneratorListener *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 = NULL;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BNGenerator *arg1 = 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;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BNGenerator *arg1 = 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;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BNGenerator *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::BayesNet< double > result;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BNGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::BayesNet< double > result;
  
  (void)self;
  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 >(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) {
    PyObject *retobj = _wrap_BNGenerator_generate__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_BNGenerator_generate__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BNGenerator_generate__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BNGenerator_generate__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  BNGenerator *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  BNGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_new_InformationTheory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InformationTheory *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__LazyPropagationT_double_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InformationTheory" "', argument " "1"" of type '" "gum::LazyPropagation< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InformationTheory" "', argument " "1"" of type '" "gum::LazyPropagation< double > &""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  arg4 = swig_obj[3];
  {
    try {
      result = (InformationTheory *)new InformationTheory(*arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InformationTheory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InformationTheory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InformationTheory *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__LazyPropagationT_double_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InformationTheory" "', argument " "1"" of type '" "gum::LazyPropagation< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InformationTheory" "', argument " "1"" of type '" "gum::LazyPropagation< double > &""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (InformationTheory *)new InformationTheory(*arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InformationTheory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InformationTheory__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InformationTheory *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InformationTheory" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InformationTheory" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > &""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  arg4 = swig_obj[3];
  {
    try {
      result = (InformationTheory *)new InformationTheory(*arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InformationTheory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InformationTheory__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InformationTheory *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InformationTheory" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InformationTheory" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > &""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (InformationTheory *)new InformationTheory(*arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InformationTheory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InformationTheory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InformationTheory", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_new_InformationTheory__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_InformationTheory__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_new_InformationTheory__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_new_InformationTheory__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InformationTheory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InformationTheory::InformationTheory(gum::LazyPropagation< double > &,PyObject *,PyObject *,PyObject *)\n"
    "    InformationTheory::InformationTheory(gum::LazyPropagation< double > &,PyObject *,PyObject *)\n"
    "    InformationTheory::InformationTheory(gum::ShaferShenoyMRFInference< double > &,PyObject *,PyObject *,PyObject *)\n"
    "    InformationTheory::InformationTheory(gum::ShaferShenoyMRFInference< double > &,PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InformationTheory_entropyXY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InformationTheory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InformationTheory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InformationTheory_entropyXY" "', argument " "1"" of type '" "InformationTheory *""'"); 
  }
  arg1 = reinterpret_cast< InformationTheory * >(argp1);
  {
    try {
      result = (double)(arg1)->entropyXY();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InformationTheory_entropyX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InformationTheory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InformationTheory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InformationTheory_entropyX" "', argument " "1"" of type '" "InformationTheory *""'"); 
  }
  arg1 = reinterpret_cast< InformationTheory * >(argp1);
  {
    try {
      result = (double)(arg1)->entropyX();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InformationTheory_entropyY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InformationTheory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InformationTheory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InformationTheory_entropyY" "', argument " "1"" of type '" "InformationTheory *""'"); 
  }
  arg1 = reinterpret_cast< InformationTheory * >(argp1);
  {
    try {
      result = (double)(arg1)->entropyY();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InformationTheory_entropyXgivenY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InformationTheory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InformationTheory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InformationTheory_entropyXgivenY" "', argument " "1"" of type '" "InformationTheory *""'"); 
  }
  arg1 = reinterpret_cast< InformationTheory * >(argp1);
  {
    try {
      result = (double)(arg1)->entropyXgivenY();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InformationTheory_entropyYgivenX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InformationTheory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InformationTheory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InformationTheory_entropyYgivenX" "', argument " "1"" of type '" "InformationTheory *""'"); 
  }
  arg1 = reinterpret_cast< InformationTheory * >(argp1);
  {
    try {
      result = (double)(arg1)->entropyYgivenX();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InformationTheory_mutualInformationXY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InformationTheory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InformationTheory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InformationTheory_mutualInformationXY" "', argument " "1"" of type '" "InformationTheory *""'"); 
  }
  arg1 = reinterpret_cast< InformationTheory * >(argp1);
  {
    try {
      result = (double)(arg1)->mutualInformationXY();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InformationTheory_variationOfInformationXY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InformationTheory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InformationTheory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InformationTheory_variationOfInformationXY" "', argument " "1"" of type '" "InformationTheory *""'"); 
  }
  arg1 = reinterpret_cast< InformationTheory * >(argp1);
  {
    try {
      result = (double)(arg1)->variationOfInformationXY();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InformationTheory_entropyXYgivenZ(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InformationTheory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InformationTheory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InformationTheory_entropyXYgivenZ" "', argument " "1"" of type '" "InformationTheory *""'"); 
  }
  arg1 = reinterpret_cast< InformationTheory * >(argp1);
  {
    try {
      result = (double)(arg1)->entropyXYgivenZ();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InformationTheory_mutualInformationXYgivenZ(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InformationTheory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InformationTheory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InformationTheory_mutualInformationXYgivenZ" "', argument " "1"" of type '" "InformationTheory *""'"); 
  }
  arg1 = reinterpret_cast< InformationTheory * >(argp1);
  {
    try {
      result = (double)(arg1)->mutualInformationXYgivenZ();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_PRMexplorer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  std::string arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_load__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_load__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_PRMexplorer_load__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_PRMexplorer_load__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_PRMexplorer_load__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_isClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_isInterface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_classes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_isAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_classReferences(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_classParameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_classImplements(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_aggType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string *arg2 = (std::string *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_classSlotChains(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_classDag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getalltheSystems(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getDirectSubClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_cpf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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::Tensor< double > *) &(arg1)->cpf(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_types(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getDirectSubTypes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getLabels(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getLabelMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_interfaces(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_interAttributes__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_PRMexplorer_interAttributes__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_PRMexplorer_interAttributes__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getSuperInterface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getDirectSubInterfaces(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getImplementations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PRMexplorer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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_new_EssentialGraph__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *result = 0 ;
  
  (void)self;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  gum::PDAG *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::EssentialGraph *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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__PDAG,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EssentialGraph" "', argument " "2"" of type '" "gum::PDAG const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_EssentialGraph" "', argument " "2"" of type '" "gum::PDAG const &""'"); 
  }
  arg2 = reinterpret_cast< gum::PDAG * >(argp2);
  {
    try {
      result = (gum::EssentialGraph *)new gum::EssentialGraph((gum::DAGmodel const &)*arg1,(gum::PDAG 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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_EssentialGraph__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DAGmodel, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_EssentialGraph__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_EssentialGraph__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_EssentialGraph__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::PDAG const &)\n"
    "    gum::EssentialGraph::EssentialGraph(gum::EssentialGraph const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EssentialGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_pdag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::PDAG result;
  
  (void)self;
  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_pdag" "', argument " "1"" of type '" "gum::EssentialGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = ((gum::EssentialGraph const *)arg1)->pdag();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::PDAG(result)), SWIGTYPE_p_gum__PDAG, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_toDot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_skeleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::UndiGraph result;
  
  (void)self;
  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_skeleton" "', argument " "1"" of type '" "gum::EssentialGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = ((gum::EssentialGraph const *)arg1)->skeleton();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_idFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "EssentialGraph_idFromName", 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_idFromName" "', argument " "1"" of type '" "gum::EssentialGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EssentialGraph_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "EssentialGraph_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::EssentialGraph 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_EssentialGraph_nameFromId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "EssentialGraph_nameFromId", 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_nameFromId" "', argument " "1"" of type '" "gum::EssentialGraph const *""'"); 
  }
  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_nameFromId" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (std::string *) &((gum::EssentialGraph const *)arg1)->nameFromId(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 const *""'"); 
  }
  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((gum::EssentialGraph const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 const *""'"); 
  }
  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((gum::EssentialGraph const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 const *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = (PyObject *)gum_EssentialGraph_edges((gum::EssentialGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_neighbours(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 const *""'"); 
  }
  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((gum::EssentialGraph const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EssentialGraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  gum::NodeId arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  gum::MarkovBlanket *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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_NullReferenceError, "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);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MarkovBlanket" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (gum::MarkovBlanket *)new gum::MarkovBlanket((gum::DAGmodel const &)*arg1,SWIG_STD_MOVE(arg2),arg3);
    } 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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  gum::MarkovBlanket *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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_NullReferenceError, "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_NullReferenceError, "invalid null reference " "in method '" "new_MarkovBlanket" "', 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 '" "new_MarkovBlanket" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (gum::MarkovBlanket *)new gum::MarkovBlanket((gum::DAGmodel const &)*arg1,(std::string const &)*arg2,arg3);
    } 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__SWIG_3(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MarkovBlanket", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_new_MarkovBlanket__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_MarkovBlanket__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_new_MarkovBlanket__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_MarkovBlanket__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,int)\n"
    "    gum::MarkovBlanket::MarkovBlanket(gum::DAGmodel const &,gum::NodeId)\n"
    "    gum::MarkovBlanket::MarkovBlanket(gum::DAGmodel const &,std::string const &,int)\n"
    "    gum::MarkovBlanket::MarkovBlanket(gum::DAGmodel const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MarkovBlanket(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_dag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DAG result;
  
  (void)self;
  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_dag" "', argument " "1"" of type '" "gum::MarkovBlanket const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovBlanket * >(argp1);
  {
    try {
      result = ((gum::MarkovBlanket const *)arg1)->dag();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::DAG(result)), SWIGTYPE_p_gum__DAG, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_toDot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = 0 ;
  gum::DAGmodel *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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 const *""'"); 
  }
  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_NullReferenceError, "invalid null reference " "in method '" "MarkovBlanket_hasSameStructure" "', argument " "2"" of type '" "gum::DAGmodel const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DAGmodel * >(argp2);
  {
    try {
      result = (bool)((gum::MarkovBlanket const *)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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 const *""'"); 
  }
  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((gum::MarkovBlanket const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 const *""'"); 
  }
  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((gum::MarkovBlanket const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MarkovBlanket_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = 0 ;
  gum::PDAG *arg2 = 0 ;
  gum::PDAG *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  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__PDAG,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StructuralComparator_compare" "', argument " "2"" of type '" "gum::PDAG const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StructuralComparator_compare" "', argument " "2"" of type '" "gum::PDAG const &""'"); 
  }
  arg2 = reinterpret_cast< gum::PDAG * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__PDAG,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StructuralComparator_compare" "', argument " "3"" of type '" "gum::PDAG const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StructuralComparator_compare" "', argument " "3"" of type '" "gum::PDAG const &""'"); 
  }
  arg3 = reinterpret_cast< gum::PDAG * >(argp3);
  {
    try {
      (arg1)->compare((gum::PDAG const &)*arg2,(gum::PDAG 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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__PDAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gum__PDAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_StructuralComparator_compare__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_StructuralComparator_compare__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_StructuralComparator_compare__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::PDAG const &,gum::PDAG const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StructuralComparator_precision_skeleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 = NULL;
  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_delete_IBayesNet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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::Tensor< double > *) &((gum::IBayesNet< double > const *)arg1)->cpt(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_variableNodeMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VariableNodeMap *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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_check(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  (void)self;
  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_check" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = ((gum::IBayesNet< double > const *)arg1)->check();
    } 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_IBayesNet___eq__(PyObject *self, PyObject *args) {
  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 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_IBayesNet___ne__(PyObject *self, PyObject *args) {
  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 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_IBayesNet_dim(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_evEq(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_evEq", 3, 3, 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_evEq" "', 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_evEq" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IBayesNet_evEq" "', 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 '" "IBayesNet_evEq" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = ((gum::IBayesNet< double > const *)arg1)->evEq((std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_evIn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_evIn", 4, 4, 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_evIn" "', 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_evIn" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IBayesNet_evIn" "', 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 '" "IBayesNet_evIn" "', 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 '" "IBayesNet_evIn" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    try {
      result = ((gum::IBayesNet< double > const *)arg1)->evIn((std::string const &)*arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_evLt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_evLt", 3, 3, 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_evLt" "', 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_evLt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IBayesNet_evLt" "', 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 '" "IBayesNet_evLt" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = ((gum::IBayesNet< double > const *)arg1)->evLt((std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_evGt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_evGt", 3, 3, 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_evGt" "', 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_evGt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IBayesNet_evGt" "', 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 '" "IBayesNet_evGt" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = ((gum::IBayesNet< double > const *)arg1)->evGt((std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_memoryFootprint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_memoryFootprint" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = ((gum::IBayesNet< double > const *)arg1)->memoryFootprint();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_ids(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_ids", 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_ids" "', argument " "1"" of type '" "gum::IBayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< 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 '" "IBayesNet_ids" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IBayesNet_ids" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (PyObject *)gum_IBayesNet_Sl_double_Sg__ids(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_nodeset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_nodeset", 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_nodeset" "', argument " "1"" of type '" "gum::IBayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< 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 '" "IBayesNet_nodeset" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IBayesNet_nodeset" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (PyObject *)gum_IBayesNet_Sl_double_Sg__nodeset(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_minimalCondSet__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  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_0((gum::IBayesNet< double > const *)arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_minimalCondSet__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  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_1((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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_IBayesNet_minimalCondSet__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_IBayesNet_minimalCondSet__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,PyObject *) const\n"
    "    gum::IBayesNet< double >::minimalCondSet(PyObject *,PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IBayesNet_isIndependent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  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 '" "IBayesNet_isIndependent" "', argument " "1"" of type '" "gum::IBayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  arg4 = swig_obj[3];
  {
    try {
      result = (bool)gum_IBayesNet_Sl_double_Sg__isIndependent__SWIG_0(arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_isIndependent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  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_isIndependent" "', argument " "1"" of type '" "gum::IBayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (bool)gum_IBayesNet_Sl_double_Sg__isIndependent__SWIG_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_isIndependent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IBayesNet_isIndependent", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_IBayesNet_isIndependent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_IBayesNet_isIndependent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IBayesNet_isIndependent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::IBayesNet< double >::isIndependent(PyObject *,PyObject *,PyObject *)\n"
    "    gum::IBayesNet< double >::isIndependent(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IBayesNet_names(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_arcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_IBayesNet_Sl_double_Sg__parents((gum::IBayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_IBayesNet_Sl_double_Sg__children((gum::IBayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_family(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_family", 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_family" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_IBayesNet_Sl_double_Sg__family((gum::IBayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_descendants(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_descendants", 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_descendants" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_IBayesNet_Sl_double_Sg__descendants((gum::IBayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_ancestors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_ancestors", 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_ancestors" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_IBayesNet_Sl_double_Sg__ancestors((gum::IBayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_moralizedAncestralGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::UndiGraph result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_moralizedAncestralGraph", 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_moralizedAncestralGraph" "', argument " "1"" of type '" "gum::IBayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_IBayesNet_Sl_double_Sg__moralizedAncestralGraph(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *IBayesNet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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 *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::BayesNet< double > result;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "BayesNet_fastPrototype" "', 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 '" "BayesNet_fastPrototype" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNet_fastPrototype" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum::BayesNet< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(result)), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  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_BayesNet_fastPrototype__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::BayesNet< double > result;
  
  (void)self;
  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_NullReferenceError, "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 >(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) {
    PyObject *retobj = _wrap_BayesNet_fastPrototype__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_BayesNet_fastPrototype__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_fastPrototype__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 &,std::string const &)\n"
    "    gum::BayesNet< double >::fastPrototype(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_BayesNet__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *result = 0 ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::BayesNet< double > *result = 0 ;
  
  (void)self;
  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 >(SWIG_STD_MOVE(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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_BayesNet__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_BayesNet__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_BayesNet__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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::Tensor< double > *) &((gum::BayesNet< double > const *)arg1)->cpt(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_cpt__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "BayesNet_cpt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< 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__TensorT_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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BayesNet_cpt__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_cpt__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VariableNodeMap *result = 0 ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::NodeId result;
  
  (void)self;
  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);
  {
    std::string *ptr = (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_NullReferenceError, "invalid null reference " "in method '" "BayesNet_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->add((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_add__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::MultiDimImplementation< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::MultiDimImplementation< double > *arg3 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_BayesNet_add__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_add__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_BayesNet_add__SWIG_3(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_BayesNet_add__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_add__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BayesNet_add__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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(std::string const &)\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_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_clear" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_BayesNet_erase__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_BayesNet_erase__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BayesNet_variable__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_variable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "BayesNet_changeVariableName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->changeVariableName(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_BayesNet_changeVariableName__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_changeVariableName__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "invalid null reference " "in method '" "BayesNet_changeVariableLabel" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      (arg1)->changeVariableLabel(SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_BayesNet_changeVariableLabel__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_BayesNet_changeVariableLabel__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addArc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BayesNet_addArc__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_addArc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_eraseArc__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_BayesNet_eraseArc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_BayesNet_eraseArc__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_eraseArc__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_reverseArc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_BayesNet_reverseArc__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_BayesNet_reverseArc__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_reverseArc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_BayesNet_addNoisyOR__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BayesNet_addNoisyOR__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_BayesNet_addNoisyORNet__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BayesNet_addNoisyORNet__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_BayesNet_addNoisyORCompound__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BayesNet_addNoisyORCompound__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_BayesNet_addNoisyAND__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BayesNet_addNoisyAND__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_BayesNet_addLogit__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BayesNet_addLogit__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_BayesNet_addCOUNT__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_addCOUNT__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_BayesNet_addEXISTS__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_addEXISTS__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_BayesNet_addFORALL__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_addFORALL__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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_addSUM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_addSUM", 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_addSUM" "', 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_addSUM" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNet_addSUM" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->addSUM((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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addWeightedArc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_BayesNet_addWeightedArc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_BayesNet_addWeightedArc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_generateCPT__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BayesNet_generateCPT__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_generateCPT__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_changeTensor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::Tensor< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  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_changeTensor" "', 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_changeTensor" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNet_changeTensor" "', argument " "3"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg3 = reinterpret_cast< gum::Tensor< double > * >(argp3);
  {
    try {
      (arg1)->changeTensor(SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_changeTensor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Tensor< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  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_changeTensor" "', 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_changeTensor" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNet_changeTensor" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNet_changeTensor" "', argument " "3"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg3 = reinterpret_cast< gum::Tensor< double > * >(argp3);
  {
    try {
      (arg1)->changeTensor((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_changeTensor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_changeTensor", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_BayesNet_changeTensor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_changeTensor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_changeTensor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::changeTensor(gum::NodeId,gum::Tensor< double > *)\n"
    "    gum::BayesNet< double >::changeTensor(std::string const &,gum::Tensor< double > *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_contextualize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::Instantiation *arg2 = 0 ;
  gum::Instantiation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  gum::BayesNet< double > result;
  
  (void)self;
  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_contextualize" "', 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__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_contextualize" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNet_contextualize" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(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 '" "BayesNet_contextualize" "', argument " "3"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNet_contextualize" "', argument " "3"" of type '" "gum::Instantiation const &""'"); 
  }
  arg3 = reinterpret_cast< gum::Instantiation * >(argp3);
  {
    try {
      result = ((gum::BayesNet< double > const *)arg1)->contextualize((gum::Instantiation const &)*arg2,(gum::Instantiation const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(result)), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_dag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DAG *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_log10DomainSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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_ids(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_ids", 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_ids" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< 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 '" "BayesNet_ids" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNet_ids" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (PyObject *)gum_BayesNet_Sl_double_Sg__ids(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_nodeset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_nodeset", 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_nodeset" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< 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 '" "BayesNet_nodeset" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNet_nodeset" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (PyObject *)gum_BayesNet_Sl_double_Sg__nodeset(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_minimalCondSet__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  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_minimalCondSet" "', 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_minimalCondSet" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = (PyObject *)gum_BayesNet_Sl_double_Sg__minimalCondSet__SWIG_0((gum::BayesNet< double > const *)arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_minimalCondSet__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  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_minimalCondSet" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (PyObject *)gum_BayesNet_Sl_double_Sg__minimalCondSet__SWIG_1((gum::BayesNet< double > const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_minimalCondSet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_minimalCondSet", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_BayesNet_minimalCondSet__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_minimalCondSet__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_minimalCondSet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::minimalCondSet(gum::NodeId,PyObject *) const\n"
    "    gum::BayesNet< double >::minimalCondSet(PyObject *,PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_isIndependent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  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_isIndependent" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  arg4 = swig_obj[3];
  {
    try {
      result = (bool)gum_BayesNet_Sl_double_Sg__isIndependent__SWIG_0(arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_isIndependent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  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_isIndependent" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (bool)gum_BayesNet_Sl_double_Sg__isIndependent__SWIG_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_isIndependent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_isIndependent", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_isIndependent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BayesNet_isIndependent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_isIndependent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::isIndependent(PyObject *,PyObject *,PyObject *)\n"
    "    gum::BayesNet< double >::isIndependent(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_names(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_names" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_BayesNet_Sl_double_Sg__names((gum::BayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_arcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_arcs" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_BayesNet_Sl_double_Sg__arcs((gum::BayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_parents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_parents", 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_parents" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_BayesNet_Sl_double_Sg__parents((gum::BayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_children", 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_children" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_BayesNet_Sl_double_Sg__children((gum::BayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_family(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_family", 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_family" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_BayesNet_Sl_double_Sg__family((gum::BayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_descendants(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_descendants", 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_descendants" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_BayesNet_Sl_double_Sg__descendants((gum::BayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_ancestors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_ancestors", 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_ancestors" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_BayesNet_Sl_double_Sg__ancestors((gum::BayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_moralizedAncestralGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::UndiGraph result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_moralizedAncestralGraph", 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_moralizedAncestralGraph" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__moralizedAncestralGraph(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadBIF__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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,SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_BayesNet_loadBIF__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_loadBIF__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_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;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_saveBIF" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveBIF__SWIG_0(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveBIF__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  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_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__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveBIF(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_saveBIF", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_saveBIF__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_saveBIF__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_saveBIF'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::saveBIF(std::string,bool)\n"
    "    gum::BayesNet< double >::saveBIF(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadDSL__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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,SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_BayesNet_loadDSL__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_loadDSL__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_loadXDSL__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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_loadXDSL" "', 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_loadXDSL" "', 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__loadXDSL__SWIG_0(arg1,SWIG_STD_MOVE(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_loadXDSL__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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_loadXDSL" "', 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_loadXDSL" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadXDSL__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadXDSL(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_loadXDSL", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_loadXDSL__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_loadXDSL__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_loadXDSL'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::loadXDSL(std::string,PyObject *)\n"
    "    gum::BayesNet< double >::loadXDSL(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveDSL__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_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;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_saveDSL" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveDSL__SWIG_0(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveDSL__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  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_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__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveDSL(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_saveDSL", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_saveDSL__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_saveDSL__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_saveDSL'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::saveDSL(std::string,bool)\n"
    "    gum::BayesNet< double >::saveDSL(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveXDSL__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_saveXDSL" "', 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_saveXDSL" "', 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 '" "BayesNet_saveXDSL" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveXDSL__SWIG_0(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveXDSL__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  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_saveXDSL" "', 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_saveXDSL" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveXDSL__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveXDSL(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_saveXDSL", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_saveXDSL__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_saveXDSL__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_saveXDSL'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::saveXDSL(std::string,bool)\n"
    "    gum::BayesNet< double >::saveXDSL(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadNET__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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,SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_BayesNet_loadNET__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_loadNET__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_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;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_saveNET" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveNET__SWIG_0(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveNET__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  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_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__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveNET(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_saveNET", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_saveNET__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_saveNET__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_saveNET'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::saveNET(std::string,bool)\n"
    "    gum::BayesNet< double >::saveNET(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadO3PRM__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  PyObject *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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,SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_BayesNet_loadO3PRM__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_loadO3PRM__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BayesNet_loadO3PRM__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_BayesNet_loadO3PRM__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_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;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_saveO3PRM" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveO3PRM__SWIG_0(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveO3PRM__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  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_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__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveO3PRM(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_saveO3PRM", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_saveO3PRM__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_saveO3PRM__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_saveO3PRM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::saveO3PRM(std::string,bool)\n"
    "    gum::BayesNet< double >::saveO3PRM(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadBIFXML__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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,SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_BayesNet_loadBIFXML__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_loadBIFXML__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_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;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_saveBIFXML" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveBIFXML__SWIG_0(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveBIFXML__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  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_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__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveBIFXML(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_saveBIFXML", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_saveBIFXML__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_saveBIFXML__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_saveBIFXML'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::saveBIFXML(std::string,bool)\n"
    "    gum::BayesNet< double >::saveBIFXML(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadUAI__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  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,SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_BayesNet_loadUAI__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_loadUAI__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_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;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_saveUAI" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveUAI__SWIG_0(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveUAI__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  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_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__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveUAI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_saveUAI", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_saveUAI__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_saveUAI__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_saveUAI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::saveUAI(std::string,bool)\n"
    "    gum::BayesNet< double >::saveUAI(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_contextualize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::BayesNet< double > result;
  
  (void)self;
  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_contextualize" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__contextualize__SWIG_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(result)), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_contextualize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_contextualize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_BayesNet_contextualize__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_contextualize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_contextualize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::contextualize(gum::Instantiation const &,gum::Instantiation const &) const\n"
    "    gum::BayesNet< double >::contextualize(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 = NULL;
  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_new_BayesNetFragment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::BayesNetFragment< double > *result = 0 ;
  
  (void)self;
  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_BayesNetFragment" "', argument " "1"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_BayesNetFragment" "', argument " "1"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (gum::BayesNetFragment< double > *)new gum::BayesNetFragment< double >((gum::IBayesNet< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__BayesNetFragmentT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_BayesNetFragment_whenNodeAdded(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  void *arg2 = 0 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_whenNodeAdded", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_whenNodeAdded" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(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 '" "BayesNetFragment_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 '" "BayesNetFragment_whenNodeAdded" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->whenNodeAdded((void const *)arg2,SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_whenNodeDeleted(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  void *arg2 = 0 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_whenNodeDeleted", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_whenNodeDeleted" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(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 '" "BayesNetFragment_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 '" "BayesNetFragment_whenNodeDeleted" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->whenNodeDeleted((void const *)arg2,SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_whenArcAdded(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  void *arg2 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_whenArcAdded", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_whenArcAdded" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(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 '" "BayesNetFragment_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 '" "BayesNetFragment_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 '" "BayesNetFragment_whenArcAdded" "', argument " "4"" of type '" "gum::NodeId""'");
  } 
  arg4 = static_cast< gum::NodeId >(val4);
  {
    try {
      (arg1)->whenArcAdded((void const *)arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_whenArcDeleted(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  void *arg2 = 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_whenArcDeleted", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_whenArcDeleted" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(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 '" "BayesNetFragment_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 '" "BayesNetFragment_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 '" "BayesNetFragment_whenArcDeleted" "', argument " "4"" of type '" "gum::NodeId""'");
  } 
  arg4 = static_cast< gum::NodeId >(val4);
  {
    try {
      (arg1)->whenArcDeleted((void const *)arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_cpt__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_cpt" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetFragment_cpt" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::BayesNetFragment< double > const *)arg1)->cpt(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_cpt__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_cpt" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_cpt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_cpt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< double > *) &((gum::BayesNetFragment< double > const *)arg1)->cpt((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_cpt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetFragment_cpt", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BayesNetFragment_cpt__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNetFragment_cpt__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetFragment_cpt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetFragment< double >::cpt(gum::NodeId) const\n"
    "    gum::BayesNetFragment< double >::cpt(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_variableNodeMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VariableNodeMap *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_variableNodeMap" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  {
    try {
      result = (gum::VariableNodeMap *) &((gum::BayesNetFragment< 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_BayesNetFragment_variable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_variable" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetFragment_variable" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::BayesNetFragment< double > const *)arg1)->variable(SWIG_STD_MOVE(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_BayesNetFragment_variable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_variable" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_variable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_variable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::BayesNetFragment< 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_BayesNetFragment_variable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetFragment_variable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BayesNetFragment_variable__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNetFragment_variable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetFragment_variable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetFragment< double >::variable(gum::NodeId) const\n"
    "    gum::BayesNetFragment< double >::variable(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_nodeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_nodeId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_nodeId" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = ((gum::BayesNetFragment< 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_BayesNetFragment_idFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_idFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_idFromName" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::BayesNetFragment< 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_BayesNetFragment_variableFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_variableFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_variableFromName" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::BayesNetFragment< 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_BayesNetFragment_toDot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_toDot" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  {
    try {
      result = ((gum::BayesNetFragment< 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_BayesNetFragment_isInstalledNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_isInstalledNode" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetFragment_isInstalledNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)((gum::BayesNetFragment< double > const *)arg1)->isInstalledNode(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_isInstalledNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_isInstalledNode" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_isInstalledNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_isInstalledNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)((gum::BayesNetFragment< double > const *)arg1)->isInstalledNode((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_BayesNetFragment_isInstalledNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetFragment_isInstalledNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BayesNetFragment_isInstalledNode__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNetFragment_isInstalledNode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetFragment_isInstalledNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetFragment< double >::isInstalledNode(gum::NodeId) const\n"
    "    gum::BayesNetFragment< double >::isInstalledNode(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_installNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_installNode" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetFragment_installNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      (arg1)->installNode(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_installNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_installNode" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_installNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_installNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->installNode((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_BayesNetFragment_installNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetFragment_installNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BayesNetFragment_installNode__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNetFragment_installNode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetFragment_installNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetFragment< double >::installNode(gum::NodeId)\n"
    "    gum::BayesNetFragment< double >::installNode(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_installAscendants__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_installAscendants" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetFragment_installAscendants" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      (arg1)->installAscendants(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_installAscendants__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_installAscendants" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_installAscendants" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_installAscendants" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->installAscendants((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_BayesNetFragment_installAscendants(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetFragment_installAscendants", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BayesNetFragment_installAscendants__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNetFragment_installAscendants__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetFragment_installAscendants'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetFragment< double >::installAscendants(gum::NodeId)\n"
    "    gum::BayesNetFragment< double >::installAscendants(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_uninstallNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_uninstallNode" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetFragment_uninstallNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      (arg1)->uninstallNode(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_uninstallNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_uninstallNode" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_uninstallNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_uninstallNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->uninstallNode((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_BayesNetFragment_uninstallNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetFragment_uninstallNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BayesNetFragment_uninstallNode__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNetFragment_uninstallNode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetFragment_uninstallNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetFragment< double >::uninstallNode(gum::NodeId)\n"
    "    gum::BayesNetFragment< double >::uninstallNode(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_installMarginal__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::Tensor< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_installMarginal" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetFragment_installMarginal" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNetFragment_installMarginal" "', argument " "3"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_installMarginal" "', argument " "3"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg3 = reinterpret_cast< gum::Tensor< double > * >(argp3);
  {
    try {
      (arg1)->installMarginal(SWIG_STD_MOVE(arg2),(gum::Tensor< double > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_installMarginal__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Tensor< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_installMarginal" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_installMarginal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_installMarginal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNetFragment_installMarginal" "', argument " "3"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_installMarginal" "', argument " "3"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg3 = reinterpret_cast< gum::Tensor< double > * >(argp3);
  {
    try {
      (arg1)->installMarginal((std::string const &)*arg2,(gum::Tensor< double > const &)*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_BayesNetFragment_installMarginal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetFragment_installMarginal", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_BayesNetFragment_installMarginal__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNetFragment_installMarginal__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetFragment_installMarginal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetFragment< double >::installMarginal(gum::NodeId,gum::Tensor< double > const &)\n"
    "    gum::BayesNetFragment< double >::installMarginal(std::string const &,gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_installCPT__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::Tensor< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_installCPT" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetFragment_installCPT" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNetFragment_installCPT" "', argument " "3"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_installCPT" "', argument " "3"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg3 = reinterpret_cast< gum::Tensor< double > * >(argp3);
  {
    try {
      (arg1)->installCPT(SWIG_STD_MOVE(arg2),(gum::Tensor< double > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_installCPT__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Tensor< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_installCPT" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_installCPT" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_installCPT" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNetFragment_installCPT" "', argument " "3"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_installCPT" "', argument " "3"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg3 = reinterpret_cast< gum::Tensor< double > * >(argp3);
  {
    try {
      (arg1)->installCPT((std::string const &)*arg2,(gum::Tensor< double > const &)*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_BayesNetFragment_installCPT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetFragment_installCPT", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_BayesNetFragment_installCPT__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNetFragment_installCPT__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetFragment_installCPT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetFragment< double >::installCPT(gum::NodeId,gum::Tensor< double > const &)\n"
    "    gum::BayesNetFragment< double >::installCPT(std::string const &,gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_uninstallCPT__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_uninstallCPT" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetFragment_uninstallCPT" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      (arg1)->uninstallCPT(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_uninstallCPT__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_uninstallCPT" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_uninstallCPT" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_uninstallCPT" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->uninstallCPT((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_BayesNetFragment_uninstallCPT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetFragment_uninstallCPT", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BayesNetFragment_uninstallCPT__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNetFragment_uninstallCPT__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetFragment_uninstallCPT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetFragment< double >::uninstallCPT(gum::NodeId)\n"
    "    gum::BayesNetFragment< double >::uninstallCPT(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_checkConsistency__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_checkConsistency" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetFragment_checkConsistency" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)((gum::BayesNetFragment< double > const *)arg1)->checkConsistency(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_checkConsistency__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_checkConsistency" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_checkConsistency" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_checkConsistency" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)((gum::BayesNetFragment< double > const *)arg1)->checkConsistency((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_BayesNetFragment_checkConsistency__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_checkConsistency" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  {
    try {
      result = (bool)((gum::BayesNetFragment< double > const *)arg1)->checkConsistency();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_checkConsistency(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetFragment_checkConsistency", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_BayesNetFragment_checkConsistency__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_BayesNetFragment_checkConsistency__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNetFragment_checkConsistency__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetFragment_checkConsistency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetFragment< double >::checkConsistency(gum::NodeId) const\n"
    "    gum::BayesNetFragment< double >::checkConsistency(std::string const &) const\n"
    "    gum::BayesNetFragment< double >::checkConsistency() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_toBN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::BayesNet< double > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_toBN" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  {
    try {
      result = ((gum::BayesNetFragment< double > const *)arg1)->toBN();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(result)), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_dag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DAG *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_dag" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  {
    try {
      result = (gum::DAG *) &((gum::BayesNetFragment< 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_BayesNetFragment_ids(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_ids", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_ids" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_ids" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_ids" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (PyObject *)gum_BayesNetFragment_Sl_double_Sg__ids(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_nodeset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_nodeset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_nodeset" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< 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 '" "BayesNetFragment_nodeset" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNetFragment_nodeset" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (PyObject *)gum_BayesNetFragment_Sl_double_Sg__nodeset(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_minimalCondSet__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_minimalCondSet" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetFragment_minimalCondSet" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = (PyObject *)gum_BayesNetFragment_Sl_double_Sg__minimalCondSet__SWIG_0((gum::BayesNetFragment< double > const *)arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_minimalCondSet__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_minimalCondSet" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (PyObject *)gum_BayesNetFragment_Sl_double_Sg__minimalCondSet__SWIG_1((gum::BayesNetFragment< double > const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_minimalCondSet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetFragment_minimalCondSet", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_BayesNetFragment_minimalCondSet__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNetFragment_minimalCondSet__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetFragment_minimalCondSet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetFragment< double >::minimalCondSet(gum::NodeId,PyObject *) const\n"
    "    gum::BayesNetFragment< double >::minimalCondSet(PyObject *,PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_isIndependent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_isIndependent" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  arg4 = swig_obj[3];
  {
    try {
      result = (bool)gum_BayesNetFragment_Sl_double_Sg__isIndependent__SWIG_0(arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_isIndependent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_isIndependent" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (bool)gum_BayesNetFragment_Sl_double_Sg__isIndependent__SWIG_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_isIndependent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetFragment_isIndependent", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNetFragment_isIndependent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BayesNetFragment_isIndependent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetFragment_isIndependent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetFragment< double >::isIndependent(PyObject *,PyObject *,PyObject *)\n"
    "    gum::BayesNetFragment< double >::isIndependent(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_names(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_names" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_BayesNetFragment_Sl_double_Sg__names((gum::BayesNetFragment< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_nodes" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_BayesNetFragment_Sl_double_Sg__nodes((gum::BayesNetFragment< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_arcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_arcs" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_BayesNetFragment_Sl_double_Sg__arcs((gum::BayesNetFragment< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_parents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_parents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_parents" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_BayesNetFragment_Sl_double_Sg__parents((gum::BayesNetFragment< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_children", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_children" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_BayesNetFragment_Sl_double_Sg__children((gum::BayesNetFragment< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_family(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_family", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_family" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_BayesNetFragment_Sl_double_Sg__family((gum::BayesNetFragment< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_descendants(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_descendants", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_descendants" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_BayesNetFragment_Sl_double_Sg__descendants((gum::BayesNetFragment< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_ancestors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_ancestors", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_ancestors" "', argument " "1"" of type '" "gum::BayesNetFragment< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_BayesNetFragment_Sl_double_Sg__ancestors((gum::BayesNetFragment< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_moralizedAncestralGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::UndiGraph result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNetFragment_moralizedAncestralGraph", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetFragmentT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetFragment_moralizedAncestralGraph" "', argument " "1"" of type '" "gum::BayesNetFragment< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetFragment< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_BayesNetFragment_Sl_double_Sg__moralizedAncestralGraph(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_LazyPropagation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::RelevantTensorsFinderType 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 ;
  
  (void)self;
  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::RelevantTensorsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantTensorsFinderType >(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::RelevantTensorsFinderType 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 ;
  
  (void)self;
  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::RelevantTensorsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantTensorsFinderType >(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::RelevantTensorsFinderType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  gum::LazyPropagation< double > *result = 0 ;
  
  (void)self;
  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::RelevantTensorsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantTensorsFinderType >(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::LazyPropagation< double > *result = 0 ;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_new_LazyPropagation__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_LazyPropagation__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_LazyPropagation__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_LazyPropagation__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::RelevantTensorsFinderType,gum::FindBarrenNodesType,bool)\n"
    "    gum::LazyPropagation< double >::LazyPropagation(gum::IBayesNet< double > const *,gum::RelevantTensorsFinderType,gum::FindBarrenNodesType)\n"
    "    gum::LazyPropagation< double >::LazyPropagation(gum::IBayesNet< double > const *,gum::RelevantTensorsFinderType)\n"
    "    gum::LazyPropagation< double >::LazyPropagation(gum::IBayesNet< double > const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LazyPropagation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::Triangulation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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_setRelevantTensorsFinderType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::RelevantTensorsFinderType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_setRelevantTensorsFinderType", 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_setRelevantTensorsFinderType" "', 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_setRelevantTensorsFinderType" "', argument " "2"" of type '" "gum::RelevantTensorsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantTensorsFinderType >(val2);
  {
    try {
      (arg1)->setRelevantTensorsFinderType(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_setFindBarrenNodesType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::FindBarrenNodesType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::JoinTree *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::JunctionTree *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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_mpe(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Instantiation result;
  
  (void)self;
  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_mpe" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = (arg1)->mpe();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Instantiation(result)), SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_mpeLog2Posterior(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::pair< gum::Instantiation,double > result;
  
  (void)self;
  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_mpeLog2Posterior" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = (arg1)->mpeLog2Posterior();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::pair< gum::Instantiation,double > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_makeInference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_posterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  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;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LazyPropagation_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__posterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_addEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LazyPropagation_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  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 == 2) {
    PyObject *retobj = _wrap_LazyPropagation_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_LazyPropagation_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_LazyPropagation_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_LazyPropagation_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_LazyPropagation_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_LazyPropagation_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LazyPropagation_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::LazyPropagation< double >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_chgEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_chgEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_chgEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LazyPropagation_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_4(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_chgEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_6(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 == 2) {
    PyObject *retobj = _wrap_LazyPropagation_chgEvidence__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_LazyPropagation_chgEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_LazyPropagation_chgEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_LazyPropagation_chgEvidence__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_LazyPropagation_chgEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_LazyPropagation_chgEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LazyPropagation_chgEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::Tensor< double > 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LazyPropagation_hasEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LazyPropagation_hasEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_eraseEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LazyPropagation_eraseEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LazyPropagation_eraseEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_hasHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LazyPropagation_hasSoftEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LazyPropagation_hasSoftEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LazyPropagation_addTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LazyPropagation_addTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_eraseTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LazyPropagation_eraseTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LazyPropagation_eraseTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LazyPropagation_isTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LazyPropagation_isTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LazyPropagation_H__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LazyPropagation_H__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  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 '" "LazyPropagation_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LazyPropagation_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_evidenceImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_BN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  (void)self;
  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_posterior__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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_2(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LazyPropagation_posterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LazyPropagation_posterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_LazyPropagation_posterior__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::LazyPropagation< double >::posterior(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_eraseAllJointTargets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_evidenceJointImpact__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  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 '" "LazyPropagation_evidenceJointImpact" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LazyPropagation_evidenceJointImpact" "', 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 '" "LazyPropagation_evidenceJointImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LazyPropagation_evidenceJointImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__evidenceJointImpact__SWIG_0(arg1,(gum::Set< std::size_t > const &)*arg2,(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_evidenceJointImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_setNumberOfThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_setNumberOfThreads", 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_setNumberOfThreads" "', 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_setNumberOfThreads" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__setNumberOfThreads(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_getNumberOfThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  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_getNumberOfThreads" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = (int)gum_LazyPropagation_Sl_double_Sg__getNumberOfThreads(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_isGumNumberOfThreadsOverriden(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_isGumNumberOfThreadsOverriden" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = (bool)gum_LazyPropagation_Sl_double_Sg__isGumNumberOfThreadsOverriden(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_setMaxMemory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_setMaxMemory", 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_setMaxMemory" "', 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_setMaxMemory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__setMaxMemory(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_setEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__evidenceImpact__SWIG_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      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) goto check_1;
    return _wrap_LazyPropagation_evidenceImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_LazyPropagation_evidenceImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LazyPropagation_evidenceImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,gum::NodeSet const &)\n"
    "    gum::LazyPropagation< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::LazyPropagation< double >::evidenceImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_jointMutualInformation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  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 = 0;
    {
      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) goto check_1;
    {
      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) goto check_1;
    return _wrap_LazyPropagation_evidenceJointImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_LazyPropagation_evidenceJointImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LazyPropagation_evidenceJointImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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(gum::NodeSet const &,gum::NodeSet const &)\n"
    "    gum::LazyPropagation< double >::evidenceJointImpact(std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::LazyPropagation< double >::evidenceJointImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_jointPosterior(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Tensor< double > result;
  
  (void)self;
  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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addJointTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *LazyPropagation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::RelevantTensorsFinderType 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::ShaferShenoyInference< double > *result = 0 ;
  
  (void)self;
  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_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::RelevantTensorsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantTensorsFinderType >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ShaferShenoyInference" "', 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_ShaferShenoyInference" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (gum::ShaferShenoyInference< double > *)new gum::ShaferShenoyInference< double >((gum::IBayesNet< double > const *)arg1,arg2,arg3,arg4);
    } 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::RelevantTensorsFinderType arg2 ;
  gum::FindBarrenNodesType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  gum::ShaferShenoyInference< double > *result = 0 ;
  
  (void)self;
  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::RelevantTensorsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantTensorsFinderType >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ShaferShenoyInference" "', argument " "3"" of type '" "gum::FindBarrenNodesType""'");
  } 
  arg3 = static_cast< gum::FindBarrenNodesType >(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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::RelevantTensorsFinderType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  gum::ShaferShenoyInference< double > *result = 0 ;
  
  (void)self;
  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::RelevantTensorsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantTensorsFinderType >(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_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::ShaferShenoyInference< double > *result = 0 ;
  
  (void)self;
  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[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ShaferShenoyInference", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_ShaferShenoyInference__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_ShaferShenoyInference__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_ShaferShenoyInference__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_ShaferShenoyInference__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::RelevantTensorsFinderType,gum::FindBarrenNodesType,bool)\n"
    "    gum::ShaferShenoyInference< double >::ShaferShenoyInference(gum::IBayesNet< double > const *,gum::RelevantTensorsFinderType,gum::FindBarrenNodesType)\n"
    "    gum::ShaferShenoyInference< double >::ShaferShenoyInference(gum::IBayesNet< double > const *,gum::RelevantTensorsFinderType)\n"
    "    gum::ShaferShenoyInference< double >::ShaferShenoyInference(gum::IBayesNet< double > const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ShaferShenoyInference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::Triangulation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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_setRelevantTensorsFinderType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::RelevantTensorsFinderType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_setRelevantTensorsFinderType", 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_setRelevantTensorsFinderType" "', 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_setRelevantTensorsFinderType" "', argument " "2"" of type '" "gum::RelevantTensorsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantTensorsFinderType >(val2);
  {
    try {
      (arg1)->setRelevantTensorsFinderType(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_setFindBarrenNodesType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::FindBarrenNodesType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::JoinTree *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::JunctionTree *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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_makeInference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_posterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  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;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyInference_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__posterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyInference_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  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 == 2) {
    PyObject *retobj = _wrap_ShaferShenoyInference_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_ShaferShenoyInference_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_ShaferShenoyInference_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_ShaferShenoyInference_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_ShaferShenoyInference_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_ShaferShenoyInference_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_ShaferShenoyInference_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::ShaferShenoyInference< double >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_chgEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_chgEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_4(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_chgEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_6(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 == 2) {
    PyObject *retobj = _wrap_ShaferShenoyInference_chgEvidence__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_ShaferShenoyInference_chgEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_ShaferShenoyInference_chgEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_ShaferShenoyInference_chgEvidence__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_ShaferShenoyInference_chgEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_ShaferShenoyInference_chgEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_ShaferShenoyInference_chgEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::Tensor< double > 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyInference_hasEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyInference_hasEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_eraseEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyInference_eraseEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyInference_eraseEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_hasHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyInference_hasSoftEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyInference_hasSoftEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyInference_addTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyInference_addTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_eraseTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyInference_eraseTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyInference_eraseTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyInference_isTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyInference_isTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyInference_H__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyInference_H__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  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 '" "ShaferShenoyInference_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyInference_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_evidenceImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_BN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  (void)self;
  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_posterior__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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_2(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyInference_posterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyInference_posterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyInference_posterior__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::ShaferShenoyInference< double >::posterior(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_eraseAllJointTargets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_evidenceJointImpact__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  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 '" "ShaferShenoyInference_evidenceJointImpact" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyInference_evidenceJointImpact" "', 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 '" "ShaferShenoyInference_evidenceJointImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyInference_evidenceJointImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__evidenceJointImpact__SWIG_0(arg1,(gum::Set< std::size_t > const &)*arg2,(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_evidenceJointImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_setNumberOfThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_setNumberOfThreads", 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_setNumberOfThreads" "', 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_setNumberOfThreads" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__setNumberOfThreads(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_getNumberOfThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  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_getNumberOfThreads" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = (int)gum_ShaferShenoyInference_Sl_double_Sg__getNumberOfThreads(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_isGumNumberOfThreadsOverriden(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_isGumNumberOfThreadsOverriden" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = (bool)gum_ShaferShenoyInference_Sl_double_Sg__isGumNumberOfThreadsOverriden(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_setMaxMemory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_setMaxMemory", 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_setMaxMemory" "', 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_setMaxMemory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__setMaxMemory(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_setEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__evidenceImpact__SWIG_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      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) goto check_1;
    return _wrap_ShaferShenoyInference_evidenceImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_ShaferShenoyInference_evidenceImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_ShaferShenoyInference_evidenceImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,gum::NodeSet const &)\n"
    "    gum::ShaferShenoyInference< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::ShaferShenoyInference< double >::evidenceImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_jointMutualInformation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  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 = 0;
    {
      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) goto check_1;
    {
      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) goto check_1;
    return _wrap_ShaferShenoyInference_evidenceJointImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_ShaferShenoyInference_evidenceJointImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_ShaferShenoyInference_evidenceJointImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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(gum::NodeSet const &,gum::NodeSet const &)\n"
    "    gum::ShaferShenoyInference< double >::evidenceJointImpact(std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::ShaferShenoyInference< double >::evidenceJointImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_jointPosterior(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Tensor< double > result;
  
  (void)self;
  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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addJointTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *ShaferShenoyInference_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::RelevantTensorsFinderType 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 ;
  
  (void)self;
  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::RelevantTensorsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantTensorsFinderType >(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::RelevantTensorsFinderType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  gum::VariableElimination< double > *result = 0 ;
  
  (void)self;
  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::RelevantTensorsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantTensorsFinderType >(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::VariableElimination< double > *result = 0 ;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_new_VariableElimination__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_VariableElimination__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_VariableElimination__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::RelevantTensorsFinderType,gum::FindBarrenNodesType)\n"
    "    gum::VariableElimination< double >::VariableElimination(gum::IBayesNet< double > const *,gum::RelevantTensorsFinderType)\n"
    "    gum::VariableElimination< double >::VariableElimination(gum::IBayesNet< double > const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_VariableElimination(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::Triangulation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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_setRelevantTensorsFinderType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::RelevantTensorsFinderType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_setRelevantTensorsFinderType", 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_setRelevantTensorsFinderType" "', 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_setRelevantTensorsFinderType" "', argument " "2"" of type '" "gum::RelevantTensorsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantTensorsFinderType >(val2);
  {
    try {
      (arg1)->setRelevantTensorsFinderType(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_setFindBarrenNodesType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::FindBarrenNodesType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::JunctionTree *result = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(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_makeInference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_posterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  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;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VariableElimination_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_VariableElimination_Sl_double_Sg__posterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_VariableElimination_posterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_VariableElimination_posterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_addEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VariableElimination_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  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 == 2) {
    PyObject *retobj = _wrap_VariableElimination_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_VariableElimination_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_VariableElimination_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_VariableElimination_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_VariableElimination_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_VariableElimination_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_VariableElimination_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::VariableElimination< double >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VariableElimination_chgEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_chgEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_chgEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VariableElimination_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_4(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_chgEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_6(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 == 2) {
    PyObject *retobj = _wrap_VariableElimination_chgEvidence__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_VariableElimination_chgEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_VariableElimination_chgEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_VariableElimination_chgEvidence__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_VariableElimination_chgEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_VariableElimination_chgEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_VariableElimination_chgEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::Tensor< double > 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_VariableElimination_hasEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_VariableElimination_hasEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_eraseEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_VariableElimination_eraseEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_VariableElimination_eraseEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_hasHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_VariableElimination_hasSoftEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_VariableElimination_hasSoftEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_VariableElimination_addTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_VariableElimination_addTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_eraseTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_VariableElimination_eraseTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_VariableElimination_eraseTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_VariableElimination_isTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_VariableElimination_isTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_VariableElimination_H__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_VariableElimination_H__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  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 '" "VariableElimination_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VariableElimination_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_VariableElimination_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_evidenceImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_BN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  (void)self;
  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_setNumberOfThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_setNumberOfThreads", 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_setNumberOfThreads" "', 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_setNumberOfThreads" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__setNumberOfThreads(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_getNumberOfThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  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_getNumberOfThreads" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      result = (int)gum_VariableElimination_Sl_double_Sg__getNumberOfThreads(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_isGumNumberOfThreadsOverriden(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_isGumNumberOfThreadsOverriden" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      result = (bool)gum_VariableElimination_Sl_double_Sg__isGumNumberOfThreadsOverriden(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_setMaxMemory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_setMaxMemory", 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_setMaxMemory" "', 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_setMaxMemory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__setMaxMemory(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_setEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_VariableElimination_Sl_double_Sg__evidenceImpact__SWIG_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      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) goto check_1;
    return _wrap_VariableElimination_evidenceImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_VariableElimination_evidenceImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_VariableElimination_evidenceImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,gum::NodeSet const &)\n"
    "    gum::VariableElimination< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::VariableElimination< double >::evidenceImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VariableElimination_jointMutualInformation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  gum::Tensor< double > result;
  
  (void)self;
  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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_jointPosterior(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Tensor< double > result;
  
  (void)self;
  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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addJointTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *VariableElimination_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::GibbsSampling< double > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_burnIn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_setVerbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_setMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_verbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_posterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  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;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GibbsSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__posterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_GibbsSampling_posterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_GibbsSampling_posterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_addEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GibbsSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  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 == 2) {
    PyObject *retobj = _wrap_GibbsSampling_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_GibbsSampling_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_GibbsSampling_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_GibbsSampling_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_GibbsSampling_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_GibbsSampling_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_GibbsSampling_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::GibbsSampling< double >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_chgEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_chgEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_chgEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GibbsSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_4(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_chgEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_6(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 == 2) {
    PyObject *retobj = _wrap_GibbsSampling_chgEvidence__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_GibbsSampling_chgEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_GibbsSampling_chgEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_GibbsSampling_chgEvidence__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_GibbsSampling_chgEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_GibbsSampling_chgEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_GibbsSampling_chgEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::Tensor< double > 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_GibbsSampling_hasEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_GibbsSampling_hasEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_eraseEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_GibbsSampling_eraseEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_GibbsSampling_eraseEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_hasHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_GibbsSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_GibbsSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_addTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_GibbsSampling_addTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_GibbsSampling_addTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_eraseTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_GibbsSampling_eraseTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_GibbsSampling_eraseTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_GibbsSampling_isTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_GibbsSampling_isTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_GibbsSampling_H__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_GibbsSampling_H__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  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 '" "GibbsSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "GibbsSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_evidenceImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_BN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  (void)self;
  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_currentPosterior__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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::Tensor< double > *) &gum_GibbsSampling_Sl_double_Sg__currentPosterior__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_currentPosterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "GibbsSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< 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__TensorT_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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_GibbsSampling_currentPosterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_GibbsSampling_currentPosterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_isDrawnAtRandom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *_wrap_GibbsSampling_setEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__evidenceImpact__SWIG_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      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) goto check_1;
    return _wrap_GibbsSampling_evidenceImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_GibbsSampling_evidenceImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_GibbsSampling_evidenceImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,gum::NodeSet const &)\n"
    "    gum::GibbsSampling< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::GibbsSampling< double >::evidenceImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *GibbsSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::ImportanceSampling< double > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_setVerbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_setMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_verbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_posterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  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;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ImportanceSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__posterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ImportanceSampling_posterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ImportanceSampling_posterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_addEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ImportanceSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  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 == 2) {
    PyObject *retobj = _wrap_ImportanceSampling_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_ImportanceSampling_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_ImportanceSampling_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_ImportanceSampling_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_ImportanceSampling_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_ImportanceSampling_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_ImportanceSampling_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::ImportanceSampling< double >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_chgEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_chgEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_chgEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ImportanceSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_4(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_chgEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_6(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 == 2) {
    PyObject *retobj = _wrap_ImportanceSampling_chgEvidence__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_ImportanceSampling_chgEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_ImportanceSampling_chgEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_ImportanceSampling_chgEvidence__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_ImportanceSampling_chgEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_ImportanceSampling_chgEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_ImportanceSampling_chgEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::Tensor< double > 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ImportanceSampling_hasEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ImportanceSampling_hasEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_eraseEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ImportanceSampling_eraseEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ImportanceSampling_eraseEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_hasHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ImportanceSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ImportanceSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_addTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ImportanceSampling_addTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ImportanceSampling_addTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_eraseTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ImportanceSampling_eraseTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ImportanceSampling_eraseTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ImportanceSampling_isTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ImportanceSampling_isTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ImportanceSampling_H__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ImportanceSampling_H__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  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 '" "ImportanceSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ImportanceSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_evidenceImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_BN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  (void)self;
  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_currentPosterior__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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::Tensor< double > *) &gum_ImportanceSampling_Sl_double_Sg__currentPosterior__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_currentPosterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "ImportanceSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< 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__TensorT_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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ImportanceSampling_currentPosterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ImportanceSampling_currentPosterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *_wrap_ImportanceSampling_setEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__evidenceImpact__SWIG_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      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) goto check_1;
    return _wrap_ImportanceSampling_evidenceImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_ImportanceSampling_evidenceImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_ImportanceSampling_evidenceImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,gum::NodeSet const &)\n"
    "    gum::ImportanceSampling< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::ImportanceSampling< double >::evidenceImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *ImportanceSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::WeightedSampling< double > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_setVerbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_setMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_verbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_posterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  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;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "WeightedSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__posterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_WeightedSampling_posterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_WeightedSampling_posterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_addEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "WeightedSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  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 == 2) {
    PyObject *retobj = _wrap_WeightedSampling_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_WeightedSampling_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_WeightedSampling_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_WeightedSampling_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_WeightedSampling_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_WeightedSampling_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_WeightedSampling_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::WeightedSampling< double >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_chgEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_chgEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_chgEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "WeightedSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_4(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_chgEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_6(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 == 2) {
    PyObject *retobj = _wrap_WeightedSampling_chgEvidence__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_WeightedSampling_chgEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_WeightedSampling_chgEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_WeightedSampling_chgEvidence__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_WeightedSampling_chgEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_WeightedSampling_chgEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_WeightedSampling_chgEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::Tensor< double > 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_WeightedSampling_hasEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_WeightedSampling_hasEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_eraseEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_WeightedSampling_eraseEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_WeightedSampling_eraseEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_hasHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_WeightedSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_WeightedSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_addTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_WeightedSampling_addTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_WeightedSampling_addTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_eraseTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_WeightedSampling_eraseTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_WeightedSampling_eraseTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_WeightedSampling_isTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_WeightedSampling_isTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_WeightedSampling_H__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_WeightedSampling_H__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  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 '" "WeightedSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "WeightedSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_evidenceImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_BN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  (void)self;
  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_currentPosterior__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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::Tensor< double > *) &gum_WeightedSampling_Sl_double_Sg__currentPosterior__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_currentPosterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "WeightedSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< 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__TensorT_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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_WeightedSampling_currentPosterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_WeightedSampling_currentPosterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *_wrap_WeightedSampling_setEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__evidenceImpact__SWIG_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      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) goto check_1;
    return _wrap_WeightedSampling_evidenceImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_WeightedSampling_evidenceImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_WeightedSampling_evidenceImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,gum::NodeSet const &)\n"
    "    gum::WeightedSampling< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::WeightedSampling< double >::evidenceImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *WeightedSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::MonteCarloSampling< double > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_setVerbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_setMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_verbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_posterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  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;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MonteCarloSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__posterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_MonteCarloSampling_posterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MonteCarloSampling_posterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_addEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MonteCarloSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  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 == 2) {
    PyObject *retobj = _wrap_MonteCarloSampling_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_MonteCarloSampling_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_MonteCarloSampling_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_MonteCarloSampling_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_MonteCarloSampling_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_MonteCarloSampling_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_MonteCarloSampling_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::MonteCarloSampling< double >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_chgEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_chgEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_chgEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_4(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_chgEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_6(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 == 2) {
    PyObject *retobj = _wrap_MonteCarloSampling_chgEvidence__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_MonteCarloSampling_chgEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_MonteCarloSampling_chgEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_MonteCarloSampling_chgEvidence__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_MonteCarloSampling_chgEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_MonteCarloSampling_chgEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_MonteCarloSampling_chgEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::Tensor< double > 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_MonteCarloSampling_hasEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MonteCarloSampling_hasEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_eraseEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_MonteCarloSampling_eraseEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MonteCarloSampling_eraseEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_hasHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_MonteCarloSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MonteCarloSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_addTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_MonteCarloSampling_addTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MonteCarloSampling_addTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_eraseTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_MonteCarloSampling_eraseTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MonteCarloSampling_eraseTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_MonteCarloSampling_isTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MonteCarloSampling_isTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_MonteCarloSampling_H__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MonteCarloSampling_H__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  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 '" "MonteCarloSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MonteCarloSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_evidenceImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_BN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  (void)self;
  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_currentPosterior__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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::Tensor< double > *) &gum_MonteCarloSampling_Sl_double_Sg__currentPosterior__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_currentPosterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "MonteCarloSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< 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__TensorT_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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_MonteCarloSampling_currentPosterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MonteCarloSampling_currentPosterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *_wrap_MonteCarloSampling_setEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__evidenceImpact__SWIG_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      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) goto check_1;
    return _wrap_MonteCarloSampling_evidenceImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_MonteCarloSampling_evidenceImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_MonteCarloSampling_evidenceImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,gum::NodeSet const &)\n"
    "    gum::MonteCarloSampling< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::MonteCarloSampling< double >::evidenceImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *MonteCarloSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_setVerbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_setMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_verbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_posterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  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;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyImportanceSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__posterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyImportanceSampling_posterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyImportanceSampling_posterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  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 == 2) {
    PyObject *retobj = _wrap_LoopyImportanceSampling_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_LoopyImportanceSampling_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_LoopyImportanceSampling_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_LoopyImportanceSampling_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_LoopyImportanceSampling_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_LoopyImportanceSampling_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyImportanceSampling_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_chgEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_chgEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_4(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_chgEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_6(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 == 2) {
    PyObject *retobj = _wrap_LoopyImportanceSampling_chgEvidence__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_LoopyImportanceSampling_chgEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_LoopyImportanceSampling_chgEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_LoopyImportanceSampling_chgEvidence__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_LoopyImportanceSampling_chgEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_LoopyImportanceSampling_chgEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyImportanceSampling_chgEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::Tensor< double > 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyImportanceSampling_hasEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyImportanceSampling_hasEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_eraseEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyImportanceSampling_eraseEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyImportanceSampling_eraseEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_hasHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyImportanceSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyImportanceSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_addTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyImportanceSampling_addTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyImportanceSampling_addTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_eraseTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyImportanceSampling_eraseTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyImportanceSampling_eraseTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyImportanceSampling_isTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyImportanceSampling_isTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyImportanceSampling_H__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyImportanceSampling_H__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  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 '" "LoopyImportanceSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyImportanceSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__evidenceImpact__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_evidenceImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_BN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  (void)self;
  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_currentPosterior__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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::Tensor< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__currentPosterior__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_currentPosterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "LoopyImportanceSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< 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__TensorT_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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyImportanceSampling_currentPosterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyImportanceSampling_currentPosterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *_wrap_LoopyImportanceSampling_setEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__evidenceImpact__SWIG_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      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) goto check_1;
    return _wrap_LoopyImportanceSampling_evidenceImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_LoopyImportanceSampling_evidenceImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyImportanceSampling_evidenceImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,gum::NodeSet const &)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::evidenceImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *LoopyImportanceSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_setVerbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_setMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_verbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_posterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  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;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyWeightedSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__posterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyWeightedSampling_posterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyWeightedSampling_posterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  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 == 2) {
    PyObject *retobj = _wrap_LoopyWeightedSampling_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_LoopyWeightedSampling_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_LoopyWeightedSampling_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_LoopyWeightedSampling_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_LoopyWeightedSampling_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_LoopyWeightedSampling_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyWeightedSampling_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_chgEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_chgEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_4(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_chgEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_6(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 == 2) {
    PyObject *retobj = _wrap_LoopyWeightedSampling_chgEvidence__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_LoopyWeightedSampling_chgEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_LoopyWeightedSampling_chgEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_LoopyWeightedSampling_chgEvidence__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_LoopyWeightedSampling_chgEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_LoopyWeightedSampling_chgEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyWeightedSampling_chgEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::Tensor< double > 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyWeightedSampling_hasEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyWeightedSampling_hasEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_eraseEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyWeightedSampling_eraseEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyWeightedSampling_eraseEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_hasHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyWeightedSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyWeightedSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_addTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyWeightedSampling_addTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyWeightedSampling_addTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_eraseTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyWeightedSampling_eraseTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyWeightedSampling_eraseTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyWeightedSampling_isTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyWeightedSampling_isTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyWeightedSampling_H__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyWeightedSampling_H__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  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 '" "LoopyWeightedSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyWeightedSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__evidenceImpact__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_evidenceImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_BN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  (void)self;
  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_currentPosterior__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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::Tensor< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__currentPosterior__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_currentPosterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "LoopyWeightedSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< 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__TensorT_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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyWeightedSampling_currentPosterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyWeightedSampling_currentPosterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *_wrap_LoopyWeightedSampling_setEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__evidenceImpact__SWIG_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      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) goto check_1;
    return _wrap_LoopyWeightedSampling_evidenceImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_LoopyWeightedSampling_evidenceImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyWeightedSampling_evidenceImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,gum::NodeSet const &)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::evidenceImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *LoopyWeightedSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_setVerbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_setMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_verbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_posterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  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;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyGibbsSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__posterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyGibbsSampling_posterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyGibbsSampling_posterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  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 == 2) {
    PyObject *retobj = _wrap_LoopyGibbsSampling_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_LoopyGibbsSampling_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_LoopyGibbsSampling_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_LoopyGibbsSampling_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_LoopyGibbsSampling_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_LoopyGibbsSampling_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyGibbsSampling_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_chgEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_chgEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_4(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_chgEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_6(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 == 2) {
    PyObject *retobj = _wrap_LoopyGibbsSampling_chgEvidence__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_LoopyGibbsSampling_chgEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_LoopyGibbsSampling_chgEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_LoopyGibbsSampling_chgEvidence__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_LoopyGibbsSampling_chgEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_LoopyGibbsSampling_chgEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyGibbsSampling_chgEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::Tensor< double > 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyGibbsSampling_hasEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyGibbsSampling_hasEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_eraseEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyGibbsSampling_eraseEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyGibbsSampling_eraseEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_hasHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyGibbsSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyGibbsSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_addTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyGibbsSampling_addTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyGibbsSampling_addTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_eraseTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyGibbsSampling_eraseTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyGibbsSampling_eraseTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyGibbsSampling_isTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyGibbsSampling_isTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyGibbsSampling_H__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyGibbsSampling_H__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  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 '" "LoopyGibbsSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyGibbsSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__evidenceImpact__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_evidenceImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_BN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  (void)self;
  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_currentPosterior__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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::Tensor< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__currentPosterior__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_currentPosterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "LoopyGibbsSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< 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__TensorT_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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyGibbsSampling_currentPosterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyGibbsSampling_currentPosterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_isDrawnAtRandom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_setEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__evidenceImpact__SWIG_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      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) goto check_1;
    return _wrap_LoopyGibbsSampling_evidenceImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_LoopyGibbsSampling_evidenceImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyGibbsSampling_evidenceImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,gum::NodeSet const &)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::evidenceImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *LoopyGibbsSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_setVerbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_setMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_verbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_posterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  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;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__posterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyMonteCarloSampling_posterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyMonteCarloSampling_posterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  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 == 2) {
    PyObject *retobj = _wrap_LoopyMonteCarloSampling_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_LoopyMonteCarloSampling_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_LoopyMonteCarloSampling_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_LoopyMonteCarloSampling_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_LoopyMonteCarloSampling_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_LoopyMonteCarloSampling_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyMonteCarloSampling_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_4(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_6(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 == 2) {
    PyObject *retobj = _wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::Tensor< double > 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyMonteCarloSampling_hasEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyMonteCarloSampling_hasEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_eraseEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyMonteCarloSampling_eraseEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyMonteCarloSampling_eraseEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_hasHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyMonteCarloSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyMonteCarloSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_addTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyMonteCarloSampling_addTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyMonteCarloSampling_addTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_eraseTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyMonteCarloSampling_eraseTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyMonteCarloSampling_eraseTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyMonteCarloSampling_isTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyMonteCarloSampling_isTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyMonteCarloSampling_H__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyMonteCarloSampling_H__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  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 '" "LoopyMonteCarloSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__evidenceImpact__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_evidenceImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_BN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  (void)self;
  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_currentPosterior__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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::Tensor< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__currentPosterior__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_currentPosterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< 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__TensorT_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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyMonteCarloSampling_currentPosterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyMonteCarloSampling_currentPosterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *_wrap_LoopyMonteCarloSampling_setEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__evidenceImpact__SWIG_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      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) goto check_1;
    return _wrap_LoopyMonteCarloSampling_evidenceImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_LoopyMonteCarloSampling_evidenceImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyMonteCarloSampling_evidenceImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,gum::NodeSet const &)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::evidenceImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *LoopyMonteCarloSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::LoopyBeliefPropagation< double > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_setVerbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_setMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_verbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_posterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  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;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyBeliefPropagation_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__posterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyBeliefPropagation_posterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyBeliefPropagation_posterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_addEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  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 == 2) {
    PyObject *retobj = _wrap_LoopyBeliefPropagation_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_LoopyBeliefPropagation_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_LoopyBeliefPropagation_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_LoopyBeliefPropagation_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_LoopyBeliefPropagation_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_LoopyBeliefPropagation_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyBeliefPropagation_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::LoopyBeliefPropagation< double >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_chgEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 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 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_chgEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_chgEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_4(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_chgEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_6(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 == 2) {
    PyObject *retobj = _wrap_LoopyBeliefPropagation_chgEvidence__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_LoopyBeliefPropagation_chgEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_LoopyBeliefPropagation_chgEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_LoopyBeliefPropagation_chgEvidence__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_LoopyBeliefPropagation_chgEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_LoopyBeliefPropagation_chgEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyBeliefPropagation_chgEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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::Tensor< double > 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyBeliefPropagation_hasEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyBeliefPropagation_hasEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_eraseEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyBeliefPropagation_eraseEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyBeliefPropagation_eraseEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_hasHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyBeliefPropagation_hasSoftEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyBeliefPropagation_hasSoftEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_addTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyBeliefPropagation_addTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyBeliefPropagation_addTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_eraseTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyBeliefPropagation_eraseTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyBeliefPropagation_eraseTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyBeliefPropagation_isTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyBeliefPropagation_isTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_LoopyBeliefPropagation_H__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_LoopyBeliefPropagation_H__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  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 '" "LoopyBeliefPropagation_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "LoopyBeliefPropagation_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_evidenceImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_BN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  (void)self;
  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_setEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__evidenceImpact__SWIG_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      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) goto check_1;
    return _wrap_LoopyBeliefPropagation_evidenceImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_LoopyBeliefPropagation_evidenceImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LoopyBeliefPropagation_evidenceImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,gum::NodeSet const &)\n"
    "    gum::LoopyBeliefPropagation< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::LoopyBeliefPropagation< double >::evidenceImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *LoopyBeliefPropagation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_ExactBNdistance__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_ExactBNdistance__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ExactBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ExactBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 = NULL;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_GibbsBNdistance__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_GibbsBNdistance__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_burnIn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_setMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_verbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_isDrawnAtRandom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 = NULL;
  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_BNDatabaseGenerator(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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_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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_drawSamples__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  gum::Size arg2 ;
  gum::Instantiation *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double result;
  
  (void)self;
  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_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);
  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 '" "BNDatabaseGenerator_drawSamples" "', argument " "3"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNDatabaseGenerator_drawSamples" "', argument " "3"" of type '" "gum::Instantiation const &""'"); 
  }
  arg3 = reinterpret_cast< gum::Instantiation * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BNDatabaseGenerator_drawSamples" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (double)(arg1)->drawSamples(SWIG_STD_MOVE(arg2),(gum::Instantiation const &)*arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_drawSamples__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  gum::Size arg2 ;
  gum::Instantiation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double result;
  
  (void)self;
  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_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);
  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 '" "BNDatabaseGenerator_drawSamples" "', argument " "3"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNDatabaseGenerator_drawSamples" "', argument " "3"" of type '" "gum::Instantiation const &""'"); 
  }
  arg3 = reinterpret_cast< gum::Instantiation * >(argp3);
  {
    try {
      result = (double)(arg1)->drawSamples(SWIG_STD_MOVE(arg2),(gum::Instantiation const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_setDiscretizedLabelModeRandom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_setDiscretizedLabelModeRandom" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    try {
      (arg1)->setDiscretizedLabelModeRandom();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_setDiscretizedLabelModeMedian(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_setDiscretizedLabelModeMedian" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    try {
      (arg1)->setDiscretizedLabelModeMedian();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_setDiscretizedLabelModeInterval(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_setDiscretizedLabelModeInterval" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    try {
      (arg1)->setDiscretizedLabelModeInterval();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_toCSV__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_BNDatabaseGenerator_toCSV__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BNDatabaseGenerator_toCSV__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BNDatabaseGenerator_toCSV__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_BNDatabaseGenerator_toCSV__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_BNDatabaseGenerator_toCSV__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_samplesNbRows(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_samplesNbRows" "', 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)->samplesNbRows();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_samplesNbCols(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_samplesNbCols" "', 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)->samplesNbCols();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_samplesAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 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 ;
  PyObject *swig_obj[3] ;
  gum::Idx result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BNDatabaseGenerator_samplesAt", 3, 3, 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_samplesAt" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > const *""'"); 
  }
  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_samplesAt" "', 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 '" "BNDatabaseGenerator_samplesAt" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      result = ((gum::learning::BNDatabaseGenerator< double > const *)arg1)->samplesAt(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_samplesLabelAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 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 ;
  PyObject *swig_obj[3] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BNDatabaseGenerator_samplesLabelAt", 3, 3, 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_samplesLabelAt" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > const *""'"); 
  }
  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_samplesLabelAt" "', 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 '" "BNDatabaseGenerator_samplesLabelAt" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      result = ((gum::learning::BNDatabaseGenerator< double > const *)arg1)->samplesLabelAt(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_setVarOrder__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  std::vector< gum::Idx,std::allocator< gum::Idx > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      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) goto check_1;
    return _wrap_BNDatabaseGenerator_setVarOrder__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNDatabaseGenerator_setVarOrder__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_BNDatabaseGenerator_setVarOrderFromCSV__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BNDatabaseGenerator_setVarOrderFromCSV__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_varOrderNames(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *_wrap_BNDatabaseGenerator_bn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::BayesNet< double > *result = 0 ;
  
  (void)self;
  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_bn" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    try {
      result = (gum::BayesNet< double > *) &(arg1)->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_BNDatabaseGenerator_varOrder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 = (PyObject *)gum_learning_BNDatabaseGenerator_Sl_double_Sg__varOrder((gum::learning::BNDatabaseGenerator< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_drawSamples__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  gum::Size arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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_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);
  arg3 = swig_obj[2];
  {
    try {
      result = (double)gum_learning_BNDatabaseGenerator_Sl_double_Sg__drawSamples__SWIG_3(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_drawSamples(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNDatabaseGenerator_drawSamples", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BNDatabaseGenerator_drawSamples__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_BNDatabaseGenerator_drawSamples__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BNDatabaseGenerator_drawSamples__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BNDatabaseGenerator_drawSamples__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNDatabaseGenerator_drawSamples'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNDatabaseGenerator< double >::drawSamples(gum::Size)\n"
    "    gum::learning::BNDatabaseGenerator< double >::drawSamples(gum::Size,gum::Instantiation const &,int)\n"
    "    gum::learning::BNDatabaseGenerator< double >::drawSamples(gum::Size,gum::Instantiation const &)\n"
    "    gum::learning::BNDatabaseGenerator< double >::drawSamples(gum::Size,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *BNDatabaseGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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_new_BNLearner__SWIG_0(PyObject *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 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "invalid null reference " "in method '" "new_BNLearner" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< 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 '" "new_BNLearner" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    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,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(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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_2(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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_3(PyObject *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 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__learning__DatabaseTable,  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_NullReferenceError, "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_4(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_NullReferenceError, "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_5(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_6(PyObject *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 ;
  
  (void)self;
  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_NullReferenceError, "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_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< gum::learning::BNLearner< double > > rvrdeleter1 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BNLearner" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "gum::learning::BNLearner< double > &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BNLearner" "', argument " "1"" of type '" "gum::learning::BNLearner< double > &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_BNLearner" "', argument " "1"" of type '" "gum::learning::BNLearner< double > &&""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__learning__DatabaseTable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_BNLearner__SWIG_3(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      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) goto check_2;
    return _wrap_new_BNLearner__SWIG_6(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    int _v = 0;
    {
      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) goto check_3;
    return _wrap_new_BNLearner__SWIG_7(self, argc, argv);
  }
check_3:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_BNLearner__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    return _wrap_new_BNLearner__SWIG_5(self, argc, argv);
  }
check_5:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_BNLearner__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_7;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_7;
    return _wrap_new_BNLearner__SWIG_4(self, argc, argv);
  }
check_7:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_BNLearner__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 &,bool const)\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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::BayesNet< double > result;
  
  (void)self;
  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 >(result)), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_learnParameters__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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 >(result)), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_learnParameters__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::DAG *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::BayesNet< double > result;
  
  (void)self;
  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_NullReferenceError, "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 >(result)), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_learnParameters__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::BayesNet< double > *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;
  
  (void)self;
  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__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_learnParameters" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_learnParameters" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(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::BayesNet< double > const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::BayesNet< double > result;
  
  (void)self;
  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__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_learnParameters" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_learnParameters" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(argp2);
  {
    try {
      result = (arg1)->learnParameters((gum::BayesNet< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  gum::BayesNet< double > result;
  
  (void)self;
  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 >(result)), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_learnParameters__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::BayesNet< double > result;
  
  (void)self;
  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 >(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) {
    PyObject *retobj = _wrap_BNLearner_learnParameters__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_BNLearner_learnParameters__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_BNLearner_learnParameters__SWIG_1(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_learnParameters__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_BNLearner_learnParameters__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_learnParameters__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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(gum::BayesNet< double > const &,bool)\n"
    "    gum::learning::BNLearner< double >::learnParameters(gum::BayesNet< double > const &)\n"
    "    gum::learning::BNLearner< double >::learnParameters(bool)\n"
    "    gum::learning::BNLearner< double >::learnParameters()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_copyState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::learning::BNLearner< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_copyState", 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_copyState" "', 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__learning__BNLearnerT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_copyState" "', argument " "2"" of type '" "gum::learning::BNLearner< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_copyState" "', argument " "2"" of type '" "gum::learning::BNLearner< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp2);
  {
    try {
      (arg1)->copyState((gum::learning::BNLearner< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setInitialDAG(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::DAG *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "BNLearner_setInitialDAG" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DAG * >(argp2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setInitialDAG((gum::DAG const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useEM__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_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);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNLearner_useEM" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useEM(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useEM__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useEM(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useEM(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_useEM", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_useEM__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_useEM__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_useEM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::useEM(double const,double const)\n"
    "    gum::learning::BNLearner< double >::useEM(double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_useEMWithRateCriterion__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_useEMWithRateCriterion" "', 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_useEMWithRateCriterion" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNLearner_useEMWithRateCriterion" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useEMWithRateCriterion(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useEMWithRateCriterion__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_useEMWithRateCriterion" "', 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_useEMWithRateCriterion" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useEMWithRateCriterion(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useEMWithRateCriterion(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_useEMWithRateCriterion", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_useEMWithRateCriterion__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_useEMWithRateCriterion__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_useEMWithRateCriterion'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::useEMWithRateCriterion(double const,double const)\n"
    "    gum::learning::BNLearner< double >::useEMWithRateCriterion(double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_useEMWithDiffCriterion__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_useEMWithDiffCriterion" "', 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_useEMWithDiffCriterion" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNLearner_useEMWithDiffCriterion" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useEMWithDiffCriterion(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useEMWithDiffCriterion__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_useEMWithDiffCriterion" "', 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_useEMWithDiffCriterion" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useEMWithDiffCriterion(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useEMWithDiffCriterion(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_useEMWithDiffCriterion", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_useEMWithDiffCriterion__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_useEMWithDiffCriterion__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_useEMWithDiffCriterion'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::useEMWithDiffCriterion(double const,double const)\n"
    "    gum::learning::BNLearner< double >::useEMWithDiffCriterion(double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_forbidEM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_forbidEM" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->forbidEM();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMsetEpsilon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_EMsetEpsilon", 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_EMsetEpsilon" "', 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_EMsetEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->EMsetEpsilon(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMdisableEpsilon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_EMdisableEpsilon" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->EMdisableEpsilon();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMenableEpsilon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_EMenableEpsilon" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->EMenableEpsilon();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMsetMinEpsilonRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_EMsetMinEpsilonRate", 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_EMsetMinEpsilonRate" "', 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_EMsetMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->EMsetMinEpsilonRate(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMdisableMinEpsilonRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_EMdisableMinEpsilonRate" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->EMdisableMinEpsilonRate();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMenableMinEpsilonRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_EMenableMinEpsilonRate" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->EMenableMinEpsilonRate();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMsetMaxIter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_EMsetMaxIter", 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_EMsetMaxIter" "', 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_EMsetMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->EMsetMaxIter(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMdisableMaxIter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_EMdisableMaxIter" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->EMdisableMaxIter();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMenableMaxIter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_EMenableMaxIter" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->EMenableMaxIter();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMsetMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_EMsetMaxTime", 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_EMsetMaxTime" "', 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_EMsetMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->EMsetMaxTime(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMdisableMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_EMdisableMaxTime" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->EMdisableMaxTime();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMenableMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_EMenableMaxTime" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->EMenableMaxTime();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMsetPeriodSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_EMsetPeriodSize", 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_EMsetPeriodSize" "', 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_EMsetPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->EMsetPeriodSize(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMPeriodSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_EMPeriodSize" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = ((gum::learning::BNLearner< double > const *)arg1)->EMPeriodSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMsetVerbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_EMsetVerbosity", 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_EMsetVerbosity" "', 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_EMsetVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->EMsetVerbosity(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useScoreAIC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useScoreAIC();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useScoreBD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useScoreBD();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useScoreBDeu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useScoreBDeu();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useScoreBIC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useScoreBIC();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useScoreK2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useScoreK2();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useScoreLog2Likelihood(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useScoreLog2Likelihood();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useNoPrior(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_useNoPrior" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useNoPrior();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useBDeuPrior__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_useBDeuPrior" "', 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_useBDeuPrior" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useBDeuPrior(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useBDeuPrior__SWIG_1(PyObject *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 ;
  
  (void)self;
  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_useBDeuPrior" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useBDeuPrior();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useBDeuPrior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_useBDeuPrior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_BNLearner_useBDeuPrior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_useBDeuPrior__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_useBDeuPrior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::useBDeuPrior(double)\n"
    "    gum::learning::BNLearner< double >::useBDeuPrior()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_useSmoothingPrior__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_useSmoothingPrior" "', 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_useSmoothingPrior" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useSmoothingPrior(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useSmoothingPrior__SWIG_1(PyObject *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 ;
  
  (void)self;
  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_useSmoothingPrior" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useSmoothingPrior();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useSmoothingPrior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_useSmoothingPrior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_BNLearner_useSmoothingPrior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_useSmoothingPrior__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_useSmoothingPrior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::useSmoothingPrior(double)\n"
    "    gum::learning::BNLearner< double >::useSmoothingPrior()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_useDirichletPrior__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_useDirichletPrior" "', 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_useDirichletPrior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_useDirichletPrior" "', 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_useDirichletPrior" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useDirichletPrior((std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useDirichletPrior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_useDirichletPrior" "', 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_useDirichletPrior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_useDirichletPrior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useDirichletPrior((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useDirichletPrior__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_useDirichletPrior" "', 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__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_useDirichletPrior" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_useDirichletPrior" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNLearner_useDirichletPrior" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useDirichletPrior((gum::BayesNet< double > const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useDirichletPrior__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_useDirichletPrior" "', 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__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_useDirichletPrior" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_useDirichletPrior" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(argp2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useDirichletPrior((gum::BayesNet< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useDirichletPrior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_useDirichletPrior", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_BNLearner_useDirichletPrior__SWIG_3(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_useDirichletPrior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_BNLearner_useDirichletPrior__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_useDirichletPrior__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_useDirichletPrior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::useDirichletPrior(std::string const &,double)\n"
    "    gum::learning::BNLearner< double >::useDirichletPrior(std::string const &)\n"
    "    gum::learning::BNLearner< double >::useDirichletPrior(gum::BayesNet< double > const &,double)\n"
    "    gum::learning::BNLearner< double >::useDirichletPrior(gum::BayesNet< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_useGreedyHillClimbing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useGreedyHillClimbing();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useLocalSearchWithTabuList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useLocalSearchWithTabuList(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useLocalSearchWithTabuList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useLocalSearchWithTabuList(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useLocalSearchWithTabuList__SWIG_2(PyObject *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 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useLocalSearchWithTabuList();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  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) {
    PyObject *retobj = _wrap_BNLearner_useLocalSearchWithTabuList__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_useLocalSearchWithTabuList__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_useLocalSearchWithTabuList__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_useLocalSearchWithTabuList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::useLocalSearchWithTabuList(gum::Size,gum::Size)\n"
    "    gum::learning::BNLearner< double >::useLocalSearchWithTabuList(gum::Size)\n"
    "    gum::learning::BNLearner< double >::useLocalSearchWithTabuList()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_useK2__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::Sequence< gum::NodeId > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useK2((gum::Sequence< gum::NodeId > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useK2__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::vector< gum::NodeId,std::allocator< gum::NodeId > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useK2((std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useMIIC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useMIIC();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useNMLCorrection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_useNMLCorrection" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useNMLCorrection();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useMDLCorrection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_useMDLCorrection" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useMDLCorrection();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useNoCorrection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_useNoCorrection" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useNoCorrection();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setMaxIndegree(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setMaxIndegree(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setSliceOrder__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::NodeProperty< gum::NodeId > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setSliceOrder((gum::NodeProperty< gum::NodeId > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setSliceOrder__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_t_std__allocatorT_std__vectorT_std__string_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_NullReferenceError, "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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setSliceOrder((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_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addForbiddenArc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "BNLearner_addForbiddenArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Arc * >(argp2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->addForbiddenArc((gum::Arc const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addForbiddenArc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->addForbiddenArc(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addForbiddenArc__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "invalid null reference " "in method '" "BNLearner_addForbiddenArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->addForbiddenArc((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 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_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) {
    PyObject *retobj = _wrap_BNLearner_addForbiddenArc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_BNLearner_addForbiddenArc__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_addForbiddenArc__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_addForbiddenArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::addForbiddenArc(gum::Arc const &)\n"
    "    gum::learning::BNLearner< double >::addForbiddenArc(gum::NodeId,gum::NodeId)\n"
    "    gum::learning::BNLearner< double >::addForbiddenArc(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseForbiddenArc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "BNLearner_eraseForbiddenArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Arc * >(argp2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->eraseForbiddenArc((gum::Arc const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseForbiddenArc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->eraseForbiddenArc(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseForbiddenArc__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "invalid null reference " "in method '" "BNLearner_eraseForbiddenArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->eraseForbiddenArc((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 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_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) {
    PyObject *retobj = _wrap_BNLearner_eraseForbiddenArc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_BNLearner_eraseForbiddenArc__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_eraseForbiddenArc__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_eraseForbiddenArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::eraseForbiddenArc(gum::Arc const &)\n"
    "    gum::learning::BNLearner< double >::eraseForbiddenArc(gum::NodeId,gum::NodeId)\n"
    "    gum::learning::BNLearner< double >::eraseForbiddenArc(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_addMandatoryArc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "BNLearner_addMandatoryArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Arc * >(argp2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->addMandatoryArc((gum::Arc const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addMandatoryArc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->addMandatoryArc(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addMandatoryArc__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "invalid null reference " "in method '" "BNLearner_addMandatoryArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->addMandatoryArc((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 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_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) {
    PyObject *retobj = _wrap_BNLearner_addMandatoryArc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_BNLearner_addMandatoryArc__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_addMandatoryArc__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_addMandatoryArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::addMandatoryArc(gum::Arc const &)\n"
    "    gum::learning::BNLearner< double >::addMandatoryArc(gum::NodeId,gum::NodeId)\n"
    "    gum::learning::BNLearner< double >::addMandatoryArc(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseMandatoryArc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "invalid null reference " "in method '" "BNLearner_eraseMandatoryArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Arc * >(argp2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->eraseMandatoryArc((gum::Arc const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseMandatoryArc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &(arg1)->eraseMandatoryArc(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseMandatoryArc__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "invalid null reference " "in method '" "BNLearner_eraseMandatoryArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->eraseMandatoryArc((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 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_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) {
    PyObject *retobj = _wrap_BNLearner_eraseMandatoryArc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_BNLearner_eraseMandatoryArc__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_eraseMandatoryArc__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_eraseMandatoryArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::eraseMandatoryArc(gum::Arc const &)\n"
    "    gum::learning::BNLearner< double >::eraseMandatoryArc(gum::NodeId,gum::NodeId)\n"
    "    gum::learning::BNLearner< double >::eraseMandatoryArc(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_addPossibleEdge__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::Edge *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_addPossibleEdge" "', 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__Edge,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_addPossibleEdge" "', argument " "2"" of type '" "gum::Edge const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_addPossibleEdge" "', argument " "2"" of type '" "gum::Edge const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Edge * >(argp2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->addPossibleEdge((gum::Edge const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addPossibleEdge__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_addPossibleEdge" "', 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_addPossibleEdge" "', 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_addPossibleEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->addPossibleEdge(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addPossibleEdge__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_addPossibleEdge" "', 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_addPossibleEdge" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_addPossibleEdge" "', 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_addPossibleEdge" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_addPossibleEdge" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->addPossibleEdge((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 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_BNLearner_addPossibleEdge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_addPossibleEdge", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_addPossibleEdge__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_BNLearner_addPossibleEdge__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_addPossibleEdge__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_addPossibleEdge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::addPossibleEdge(gum::Edge const &)\n"
    "    gum::learning::BNLearner< double >::addPossibleEdge(gum::NodeId,gum::NodeId)\n"
    "    gum::learning::BNLearner< double >::addPossibleEdge(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_erasePossibleEdge__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::Edge *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_erasePossibleEdge" "', 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__Edge,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_erasePossibleEdge" "', argument " "2"" of type '" "gum::Edge const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_erasePossibleEdge" "', argument " "2"" of type '" "gum::Edge const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Edge * >(argp2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->erasePossibleEdge((gum::Edge const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_erasePossibleEdge__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_erasePossibleEdge" "', 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_erasePossibleEdge" "', 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_erasePossibleEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->erasePossibleEdge(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_erasePossibleEdge__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_erasePossibleEdge" "', 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_erasePossibleEdge" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_erasePossibleEdge" "', 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_erasePossibleEdge" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_erasePossibleEdge" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->erasePossibleEdge((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 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_BNLearner_erasePossibleEdge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_erasePossibleEdge", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_erasePossibleEdge__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_BNLearner_erasePossibleEdge__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_erasePossibleEdge__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_erasePossibleEdge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::erasePossibleEdge(gum::Edge const &)\n"
    "    gum::learning::BNLearner< double >::erasePossibleEdge(gum::NodeId,gum::NodeId)\n"
    "    gum::learning::BNLearner< double >::erasePossibleEdge(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_setPossibleEdges__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::EdgeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_setPossibleEdges" "', 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__SetT_gum__Edge_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_setPossibleEdges" "', argument " "2"" of type '" "gum::EdgeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_setPossibleEdges" "', argument " "2"" of type '" "gum::EdgeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::EdgeSet * >(argp2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setPossibleEdges((gum::EdgeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setPossibleSkeleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::UndiGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_setPossibleSkeleton", 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_setPossibleSkeleton" "', 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__UndiGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_setPossibleSkeleton" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_setPossibleSkeleton" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::UndiGraph * >(argp2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setPossibleSkeleton((gum::UndiGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addNoParentNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_addNoParentNode" "', 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_addNoParentNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->addNoParentNode(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addNoParentNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_addNoParentNode" "', 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_addNoParentNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_addNoParentNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->addNoParentNode((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addNoParentNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_addNoParentNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BNLearner_addNoParentNode__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_addNoParentNode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_addNoParentNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::addNoParentNode(gum::NodeId)\n"
    "    gum::learning::BNLearner< double >::addNoParentNode(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseNoParentNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_eraseNoParentNode" "', 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_eraseNoParentNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->eraseNoParentNode(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseNoParentNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_eraseNoParentNode" "', 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_eraseNoParentNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_eraseNoParentNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->eraseNoParentNode((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseNoParentNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_eraseNoParentNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BNLearner_eraseNoParentNode__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_eraseNoParentNode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_eraseNoParentNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::eraseNoParentNode(gum::NodeId)\n"
    "    gum::learning::BNLearner< double >::eraseNoParentNode(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_addNoChildrenNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_addNoChildrenNode" "', 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_addNoChildrenNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->addNoChildrenNode(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addNoChildrenNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_addNoChildrenNode" "', 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_addNoChildrenNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_addNoChildrenNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->addNoChildrenNode((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addNoChildrenNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_addNoChildrenNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BNLearner_addNoChildrenNode__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_addNoChildrenNode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_addNoChildrenNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::addNoChildrenNode(gum::NodeId)\n"
    "    gum::learning::BNLearner< double >::addNoChildrenNode(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseNoChildrenNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_eraseNoChildrenNode" "', 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_eraseNoChildrenNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->eraseNoChildrenNode(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseNoChildrenNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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_eraseNoChildrenNode" "', 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_eraseNoChildrenNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_eraseNoChildrenNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->eraseNoChildrenNode((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseNoChildrenNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_eraseNoChildrenNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BNLearner_eraseNoChildrenNode__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_eraseNoChildrenNode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_eraseNoChildrenNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::eraseNoChildrenNode(gum::NodeId)\n"
    "    gum::learning::BNLearner< double >::eraseNoChildrenNode(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_isConstraintBased(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_isConstraintBased" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (bool)((gum::learning::BNLearner< double > const *)arg1)->isConstraintBased();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_isScoreBased(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_isScoreBased" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (bool)((gum::learning::BNLearner< double > const *)arg1)->isScoreBased();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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___repr__" "', 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____repr__((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___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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___str__" "', 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____str__((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_setVerbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_setMaxTime", 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_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(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setPeriodSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_verbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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_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((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_periodSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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_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((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_messageApproximationScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DAG result;
  
  (void)self;
  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(result)), SWIGTYPE_p_gum__DAG, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_learnPDAG(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::PDAG result;
  
  (void)self;
  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_learnPDAG" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__learnPDAG(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::PDAG(result)), SWIGTYPE_p_gum__PDAG, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_names(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string *result = 0 ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setDatabaseWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_setRecordWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::size_t arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_setRecordWeight", 3, 3, 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_setRecordWeight" "', 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_setRecordWeight" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNLearner_setRecordWeight" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__setRecordWeight(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_databaseWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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_databaseWeight" "', 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__databaseWeight((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_recordWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_recordWeight", 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_recordWeight" "', 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_recordWeight" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__recordWeight((gum::learning::BNLearner< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_hasMissingValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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(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_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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_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_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_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_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_NullReferenceError, "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_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 = 0;
    {
      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) goto check_1;
    return _wrap_BNLearner_logLikelihood__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_logLikelihood__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      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) goto check_3;
    {
      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) goto check_3;
    return _wrap_BNLearner_logLikelihood__SWIG_0(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_logLikelihood__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_logLikelihood'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::logLikelihood(std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)\n"
    "    gum::learning::BNLearner< double >::logLikelihood(std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)\n"
    "    gum::learning::BNLearner< double >::logLikelihood(std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::learning::BNLearner< double >::logLikelihood(std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_score__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::vector< gum::NodeId,std::allocator< gum::NodeId > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double result;
  
  (void)self;
  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_score" "', 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_score" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  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_score" "', argument " "3"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_score" "', 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__score__SWIG_0(arg1,SWIG_STD_MOVE(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_score__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  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_score" "', 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_score" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__score__SWIG_1(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_score__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  double result;
  
  (void)self;
  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_score" "', 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_score" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_score" "', 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 '" "BNLearner_score" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_score" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__score__SWIG_2(arg1,(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_score__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_score" "', 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_score" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_score" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__score__SWIG_3(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_BNLearner_score(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_score", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BNLearner_score__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_score__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      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) goto check_3;
    return _wrap_BNLearner_score__SWIG_0(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_score__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_score'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::score(gum::NodeId,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)\n"
    "    gum::learning::BNLearner< double >::score(gum::NodeId)\n"
    "    gum::learning::BNLearner< double >::score(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::learning::BNLearner< double >::score(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_mutualInformation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  std::vector< gum::NodeId,std::allocator< gum::NodeId > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double result;
  
  (void)self;
  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_mutualInformation" "', 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_mutualInformation" "', 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_mutualInformation" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BNLearner_mutualInformation" "', argument " "4"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_mutualInformation" "', argument " "4"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< gum::NodeId,std::allocator< gum::NodeId > > * >(argp4);
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__mutualInformation__SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::size_t,std::allocator< std::size_t > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_mutualInformation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  double result;
  
  (void)self;
  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_mutualInformation" "', 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_mutualInformation" "', 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_mutualInformation" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__mutualInformation__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_mutualInformation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  double result;
  
  (void)self;
  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_mutualInformation" "', 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_mutualInformation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_mutualInformation" "', 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_mutualInformation" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_mutualInformation" "', 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_mutualInformation" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_mutualInformation" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__mutualInformation__SWIG_2(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(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_mutualInformation__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_mutualInformation" "', 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_mutualInformation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_mutualInformation" "', 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_mutualInformation" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_mutualInformation" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__mutualInformation__SWIG_3(arg1,(std::string const &)*arg2,(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_mutualInformation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_mutualInformation", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BNLearner_mutualInformation__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_mutualInformation__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_ConvertPtr(argv[3], 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) goto check_3;
    return _wrap_BNLearner_mutualInformation__SWIG_0(self, argc, argv);
  }
check_3:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_BNLearner_mutualInformation__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_mutualInformation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::mutualInformation(gum::NodeId,gum::NodeId,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)\n"
    "    gum::learning::BNLearner< double >::mutualInformation(gum::NodeId,gum::NodeId)\n"
    "    gum::learning::BNLearner< double >::mutualInformation(std::string const &,std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::learning::BNLearner< double >::mutualInformation(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_correctedMutualInformation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  std::vector< gum::NodeId,std::allocator< gum::NodeId > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double result;
  
  (void)self;
  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_correctedMutualInformation" "', 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_correctedMutualInformation" "', 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_correctedMutualInformation" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BNLearner_correctedMutualInformation" "', argument " "4"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_correctedMutualInformation" "', argument " "4"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< gum::NodeId,std::allocator< gum::NodeId > > * >(argp4);
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__correctedMutualInformation__SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::size_t,std::allocator< std::size_t > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_correctedMutualInformation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  double result;
  
  (void)self;
  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_correctedMutualInformation" "', 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_correctedMutualInformation" "', 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_correctedMutualInformation" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__correctedMutualInformation__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_correctedMutualInformation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  double result;
  
  (void)self;
  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_correctedMutualInformation" "', 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_correctedMutualInformation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_correctedMutualInformation" "', 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_correctedMutualInformation" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_correctedMutualInformation" "', 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_correctedMutualInformation" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_correctedMutualInformation" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__correctedMutualInformation__SWIG_2(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(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_correctedMutualInformation__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  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_correctedMutualInformation" "', 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_correctedMutualInformation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_correctedMutualInformation" "', 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_correctedMutualInformation" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_correctedMutualInformation" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__correctedMutualInformation__SWIG_3(arg1,(std::string const &)*arg2,(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_correctedMutualInformation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_correctedMutualInformation", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BNLearner_correctedMutualInformation__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_correctedMutualInformation__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_ConvertPtr(argv[3], 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) goto check_3;
    return _wrap_BNLearner_correctedMutualInformation__SWIG_0(self, argc, argv);
  }
check_3:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_BNLearner_correctedMutualInformation__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_correctedMutualInformation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::correctedMutualInformation(gum::NodeId,gum::NodeId,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)\n"
    "    gum::learning::BNLearner< double >::correctedMutualInformation(gum::NodeId,gum::NodeId)\n"
    "    gum::learning::BNLearner< double >::correctedMutualInformation(std::string const &,std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::learning::BNLearner< double >::correctedMutualInformation(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_rawPseudoCount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::vector< gum::NodeId,std::allocator< gum::NodeId > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< double,std::allocator< double > > result;
  
  (void)self;
  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_rawPseudoCount" "', 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_rawPseudoCount" "', argument " "2"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_rawPseudoCount" "', 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 = gum_learning_BNLearner_Sl_double_Sg__rawPseudoCount__SWIG_0(arg1,(std::vector< std::size_t,std::allocator< std::size_t > > const &)*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_BNLearner_rawPseudoCount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< double,std::allocator< double > > result;
  
  (void)self;
  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_rawPseudoCount" "', 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_rawPseudoCount" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_rawPseudoCount" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__rawPseudoCount__SWIG_1(arg1,(std::vector< std::string,std::allocator< 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_BNLearner_rawPseudoCount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_rawPseudoCount", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      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) goto check_1;
    return _wrap_BNLearner_rawPseudoCount__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_rawPseudoCount__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_rawPseudoCount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::rawPseudoCount(std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)\n"
    "    gum::learning::BNLearner< double >::rawPseudoCount(std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_nbRows(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_domainSize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Size result;
  
  (void)self;
  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_domainSize" "', 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_domainSize" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__domainSize__SWIG_0((gum::learning::BNLearner< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_domainSize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Size result;
  
  (void)self;
  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_domainSize" "', 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_domainSize" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_domainSize" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__domainSize__SWIG_1((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_domainSize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_domainSize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_BNLearner_domainSize__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_domainSize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_domainSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::domainSize(gum::NodeId) const\n"
    "    gum::learning::BNLearner< double >::domainSize(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_isUsingEM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_isUsingEM" "', 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__isUsingEM((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_EMEpsilon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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_EMEpsilon" "', 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__EMEpsilon((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_EMisEnabledEpsilon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_EMisEnabledEpsilon" "', 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__EMisEnabledEpsilon((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_EMMinEpsilonRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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_EMMinEpsilonRate" "', 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__EMMinEpsilonRate((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_EMisEnabledMinEpsilonRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_EMisEnabledMinEpsilonRate" "', 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__EMisEnabledMinEpsilonRate((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_EMMaxIter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_EMMaxIter" "', 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__EMMaxIter((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_EMisEnabledMaxIter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_EMisEnabledMaxIter" "', 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__EMisEnabledMaxIter((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_EMMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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_EMMaxTime" "', 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__EMMaxTime((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_EMisEnabledMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_EMisEnabledMaxTime" "', 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__EMisEnabledMaxTime((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_EMVerbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_EMVerbosity" "', 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__EMVerbosity((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_EMnbrIterations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_EMnbrIterations" "', 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__EMnbrIterations((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_EMHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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_EMHistory" "', 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__EMHistory((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_EMStateApproximationScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration::ApproximationSchemeSTATE result;
  
  (void)self;
  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_EMStateApproximationScheme" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration::ApproximationSchemeSTATE)gum_learning_BNLearner_Sl_double_Sg__EMStateApproximationScheme((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_EMStateMessage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_EMStateMessage" "', 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__EMStateMessage((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_setNumberOfThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_setNumberOfThreads", 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_setNumberOfThreads" "', 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_setNumberOfThreads" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__setNumberOfThreads(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_getNumberOfThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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_getNumberOfThreads" "', 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__getNumberOfThreads((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_isGumNumberOfThreadsOverriden(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_isGumNumberOfThreadsOverriden" "', 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__isGumNumberOfThreadsOverriden((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_chi2__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_BNLearner_chi2__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BNLearner_chi2__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_G2__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  
  (void)self;
  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_G2" "', 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_G2" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_G2" "', 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_G2" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_G2" "', 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_G2" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_G2" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PyObject *)gum_learning_BNLearner_Sl_double_Sg__G2__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_G2__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 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 ;
  
  (void)self;
  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_G2" "', 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_G2" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_G2" "', 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_G2" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_G2" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (PyObject *)gum_learning_BNLearner_Sl_double_Sg__G2__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_G2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_G2", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_BNLearner_G2__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BNLearner_G2__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_G2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::G2(std::string const &,std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::learning::BNLearner< double >::G2(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner__EM_warning(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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__EM_warning" "', 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___EM_warning((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_setSliceOrder__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &gum_learning_BNLearner_Sl_double_Sg__setSliceOrder__SWIG_2(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  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 = 0;
    {
      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) goto check_1;
    return _wrap_BNLearner_setSliceOrder__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__vectorT_std__string_t_std__allocatorT_std__vectorT_std__string_t_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_BNLearner_setSliceOrder__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_setSliceOrder__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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(gum::NodeProperty< gum::NodeId > const &)\n"
    "    gum::learning::BNLearner< double >::setSliceOrder(std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &)\n"
    "    gum::learning::BNLearner< double >::setSliceOrder(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_useK2__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  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 {
      result = (gum::learning::BNLearner< double > *) &gum_learning_BNLearner_Sl_double_Sg__useK2__SWIG_2(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  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 = 0;
    {
      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) goto check_1;
    return _wrap_BNLearner_useK2__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      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) goto check_2;
    return _wrap_BNLearner_useK2__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_useK2__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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(gum::Sequence< gum::NodeId > const &)\n"
    "    gum::learning::BNLearner< double >::useK2(std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)\n"
    "    gum::learning::BNLearner< double >::useK2(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_latentVariables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_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(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_state" "', 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__state(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setPossibleEdges__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  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_setPossibleEdges" "', 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__setPossibleEdges__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setPossibleEdges(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_setPossibleEdges", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__SetT_gum__Edge_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_BNLearner_setPossibleEdges__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_setPossibleEdges__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_setPossibleEdges'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::setPossibleEdges(gum::EdgeSet const &)\n"
    "    gum::learning::BNLearner< double >::setPossibleEdges(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *BNLearner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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_CredalNet__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *result = 0 ;
  
  (void)self;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_CredalNet__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_CredalNet__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_CredalNet__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_new_CredalNet__SWIG_3(self, argc, argv);
  }
check_4:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_CredalNet__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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] ;
  
  (void)self;
  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_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_t_std__allocatorT_std__vectorT_double_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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_t_std__allocatorT_std__vectorT_double_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_NullReferenceError, "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,SWIG_STD_MOVE(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 = 0;
    {
      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) goto check_1;
    PyObject *retobj = _wrap_CredalNet_setCPT__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_CredalNet_setCPT__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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] ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_NullReferenceError, "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,SWIG_STD_MOVE(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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_CredalNet_fillConstraint__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 5) {
    PyObject *retobj = _wrap_CredalNet_fillConstraint__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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;
  
  (void)self;
  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(result)), SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_domainSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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 ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  double arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_CredalNet_bnToCredal__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_CredalNet_bnToCredal__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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,bool,bool)\n"
    "    gum::credal::CredalNet< double >::bnToCredal(double,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CredalNet_intervalToCredalWithFiles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  gum::Idx arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_idmLearning__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_idmLearning__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_CredalNet_idmLearning__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_CredalNet_idmLearning__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_CredalNet_idmLearning__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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] ;
  
  (void)self;
  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_NullReferenceError, "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_NullReferenceError, "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_computeBinaryCPTMinMax(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_computeBinaryCPTMinMax" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      (arg1)->computeBinaryCPTMinMax();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_src_bn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::BayesNet< double > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::BayesNet< double > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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 ;
  
  (void)self;
  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_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_credalNet_srcCpt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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 ;
  
  (void)self;
  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_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_currentNodeType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_hasComputedBinaryCPTMinMax(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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_hasComputedBinaryCPTMinMax" "', 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)->hasComputedBinaryCPTMinMax();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_get_binaryCPT_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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 ;
  
  (void)self;
  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_binaryCPT_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_binaryCPT_min();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_get_binaryCPT_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 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 ;
  
  (void)self;
  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_binaryCPT_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_binaryCPT_max();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 = NULL;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CNMonteCarloSampling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_setMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_verbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 = gum_credal_CNMonteCarloSampling_Sl_double_Sg__marginalMax__SWIG_0((gum::credal::CNMonteCarloSampling< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_marginalMin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 = gum_credal_CNMonteCarloSampling_Sl_double_Sg__marginalMin__SWIG_0((gum::credal::CNMonteCarloSampling< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_marginalMax__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 = gum_credal_CNMonteCarloSampling_Sl_double_Sg__marginalMax__SWIG_1((gum::credal::CNMonteCarloSampling< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_CNMonteCarloSampling_marginalMax__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_CNMonteCarloSampling_marginalMax__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 = gum_credal_CNMonteCarloSampling_Sl_double_Sg__marginalMin__SWIG_1((gum::credal::CNMonteCarloSampling< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_CNMonteCarloSampling_marginalMin__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_CNMonteCarloSampling_marginalMin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 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 ;
  
  (void)self;
  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_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_NullReferenceError, "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 *_wrap_CNMonteCarloSampling_eraseAllEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_eraseAllEvidence" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      gum_credal_CNMonteCarloSampling_Sl_double_Sg__eraseAllEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_addEvidence" "', 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_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 '" "CNMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_credal_CNMonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_addEvidence" "', 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_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNMonteCarloSampling_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 '" "CNMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_credal_CNMonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,SWIG_STD_MOVE(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_CNMonteCarloSampling_addEvidence__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_addEvidence" "', 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_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 '" "CNMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_credal_CNMonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_2(arg1,SWIG_STD_MOVE(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_CNMonteCarloSampling_addEvidence__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_addEvidence" "', 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_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNMonteCarloSampling_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 '" "CNMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_credal_CNMonteCarloSampling_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_CNMonteCarloSampling_addEvidence__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_addEvidence" "', 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_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 '" "CNMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_credal_CNMonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_4(arg1,SWIG_STD_MOVE(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_CNMonteCarloSampling_addEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_addEvidence" "', 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_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNMonteCarloSampling_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 '" "CNMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_credal_CNMonteCarloSampling_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_CNMonteCarloSampling_addEvidence__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_addEvidence" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CNMonteCarloSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNMonteCarloSampling_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_credal_CNMonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CNMonteCarloSampling_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_CNMonteCarloSampling_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_CNMonteCarloSampling_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_CNMonteCarloSampling_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_CNMonteCarloSampling_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_CNMonteCarloSampling_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_CNMonteCarloSampling_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_CNMonteCarloSampling_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CNMonteCarloSampling_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::credal::CNMonteCarloSampling< double >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::credal::CNMonteCarloSampling< double >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::credal::CNMonteCarloSampling< double >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::credal::CNMonteCarloSampling< double >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::credal::CNMonteCarloSampling< double >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::credal::CNMonteCarloSampling< double >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::credal::CNMonteCarloSampling< double >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_CN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::credal::CredalNet< double > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_CN" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (gum::credal::CredalNet< double > *) &gum_credal_CNMonteCarloSampling_Sl_double_Sg__CN((gum::credal::CNMonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CNMonteCarloSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  gum::credal::CNLoopyPropagation< double >::InferenceType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::credal::CNLoopyPropagation< double >::InferenceType result;
  
  (void)self;
  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) {
    PyObject *retobj = _wrap_CNLoopyPropagation_inferenceType__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_CNLoopyPropagation_inferenceType__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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_saveInference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_setMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_verbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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 = gum_credal_CNLoopyPropagation_Sl_double_Sg__marginalMax__SWIG_0((gum::credal::CNLoopyPropagation< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_marginalMin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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 = gum_credal_CNLoopyPropagation_Sl_double_Sg__marginalMin__SWIG_0((gum::credal::CNLoopyPropagation< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_marginalMax__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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 = gum_credal_CNLoopyPropagation_Sl_double_Sg__marginalMax__SWIG_1((gum::credal::CNLoopyPropagation< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_CNLoopyPropagation_marginalMax__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_CNLoopyPropagation_marginalMax__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  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 = gum_credal_CNLoopyPropagation_Sl_double_Sg__marginalMin__SWIG_1((gum::credal::CNLoopyPropagation< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  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 = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_CNLoopyPropagation_marginalMin__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_CNLoopyPropagation_marginalMin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 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 ;
  
  (void)self;
  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_NullReferenceError, "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 *_wrap_CNLoopyPropagation_eraseAllEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 {
      gum_credal_CNLoopyPropagation_Sl_double_Sg__eraseAllEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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_addEvidence" "', 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_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 '" "CNLoopyPropagation_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_credal_CNLoopyPropagation_Sl_double_Sg__addEvidence__SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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_addEvidence" "', 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_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNLoopyPropagation_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 '" "CNLoopyPropagation_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_credal_CNLoopyPropagation_Sl_double_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,SWIG_STD_MOVE(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_CNLoopyPropagation_addEvidence__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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_addEvidence" "', 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_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 '" "CNLoopyPropagation_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNLoopyPropagation_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_credal_CNLoopyPropagation_Sl_double_Sg__addEvidence__SWIG_2(arg1,SWIG_STD_MOVE(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_CNLoopyPropagation_addEvidence__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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_addEvidence" "', 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_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNLoopyPropagation_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 '" "CNLoopyPropagation_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNLoopyPropagation_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_credal_CNLoopyPropagation_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_CNLoopyPropagation_addEvidence__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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_addEvidence" "', 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_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 '" "CNLoopyPropagation_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNLoopyPropagation_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_credal_CNLoopyPropagation_Sl_double_Sg__addEvidence__SWIG_4(arg1,SWIG_STD_MOVE(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_CNLoopyPropagation_addEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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_addEvidence" "', 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_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNLoopyPropagation_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 '" "CNLoopyPropagation_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNLoopyPropagation_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_credal_CNLoopyPropagation_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_CNLoopyPropagation_addEvidence__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_addEvidence" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CNLoopyPropagation_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CNLoopyPropagation_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_credal_CNLoopyPropagation_Sl_double_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_CNLoopyPropagation_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_CNLoopyPropagation_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_CNLoopyPropagation_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_CNLoopyPropagation_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_CNLoopyPropagation_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_CNLoopyPropagation_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_CNLoopyPropagation_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CNLoopyPropagation_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::credal::CNLoopyPropagation< double >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::credal::CNLoopyPropagation< double >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::credal::CNLoopyPropagation< double >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::credal::CNLoopyPropagation< double >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::credal::CNLoopyPropagation< double >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::credal::CNLoopyPropagation< double >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::credal::CNLoopyPropagation< double >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_CN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::credal::CredalNet< double > *result = 0 ;
  
  (void)self;
  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_CN" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      result = (gum::credal::CredalNet< double > *) &gum_credal_CNLoopyPropagation_Sl_double_Sg__CN((gum::credal::CNLoopyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CNLoopyPropagation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  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_IDGenerator_generate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IDGenerator *arg1 = 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;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),arg3,arg4,arg5,arg6);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IDGenerator *arg1 = 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;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),arg3,arg4,arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IDGenerator *arg1 = 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;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IDGenerator *arg1 = 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;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IDGenerator *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::InfluenceDiagram< double > result;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IDGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::InfluenceDiagram< double > result;
  
  (void)self;
  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 >(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) {
    PyObject *retobj = _wrap_IDGenerator_generate__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_IDGenerator_generate__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_IDGenerator_generate__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_IDGenerator_generate__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_IDGenerator_generate__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_IDGenerator_generate__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  IDGenerator *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  IDGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 = NULL;
  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_InfluenceDiagram_fastPrototype__SWIG_0(PyObject *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::InfluenceDiagram< double > result;
  
  (void)self;
  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 '" "InfluenceDiagram_fastPrototype" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_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 '" "InfluenceDiagram_fastPrototype" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = gum::InfluenceDiagram< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype((std::string const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::InfluenceDiagram< double >(result)), SWIGTYPE_p_gum__InfluenceDiagramT_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_InfluenceDiagram_fastPrototype__SWIG_1(PyObject *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::InfluenceDiagram< double > result;
  
  (void)self;
  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 '" "InfluenceDiagram_fastPrototype" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_fastPrototype" "', 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 '" "InfluenceDiagram_fastPrototype" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_fastPrototype" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum::InfluenceDiagram< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::InfluenceDiagram< double >(result)), SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_POINTER_OWN |  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_InfluenceDiagram_fastPrototype__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::InfluenceDiagram< double > result;
  
  (void)self;
  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 '" "InfluenceDiagram_fastPrototype" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_fastPrototype" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = gum::InfluenceDiagram< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::InfluenceDiagram< double >(result)), SWIGTYPE_p_gum__InfluenceDiagramT_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_InfluenceDiagram_fastPrototype(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_fastPrototype", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_InfluenceDiagram_fastPrototype__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_InfluenceDiagram_fastPrototype__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram_fastPrototype__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_fastPrototype'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::fastPrototype(std::string const &,gum::Size)\n"
    "    gum::InfluenceDiagram< double >::fastPrototype(std::string const &,std::string const &)\n"
    "    gum::InfluenceDiagram< double >::fastPrototype(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_InfluenceDiagram__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *result = 0 ;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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 *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 ;
  
  (void)self;
  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_NullReferenceError, "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) {
    PyObject *retobj = _wrap_new_InfluenceDiagram__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_InfluenceDiagram__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::InfluenceDiagram< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram___eq__", 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___eq__" "', 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__InfluenceDiagramT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram___eq__" "', argument " "2"" of type '" "gum::InfluenceDiagram< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram___eq__" "', argument " "2"" of type '" "gum::InfluenceDiagram< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp2);
  {
    try {
      result = (bool)((gum::InfluenceDiagram< double > const *)arg1)->operator ==((gum::InfluenceDiagram< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::InfluenceDiagram< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram___ne__", 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___ne__" "', 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__InfluenceDiagramT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram___ne__" "', argument " "2"" of type '" "gum::InfluenceDiagram< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram___ne__" "', argument " "2"" of type '" "gum::InfluenceDiagram< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp2);
  {
    try {
      result = (bool)((gum::InfluenceDiagram< double > const *)arg1)->operator !=((gum::InfluenceDiagram< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_toDot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_clear" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_cpt__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_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::Tensor< double > *) &((gum::InfluenceDiagram< double > const *)arg1)->cpt(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_cpt__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_cpt" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  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_cpt" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::Tensor< double > *) &((gum::InfluenceDiagram< double > const *)arg1)->cpt(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_cpt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_cpt", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_InfluenceDiagram_cpt__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram_cpt__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_cpt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::cpt(gum::NodeId) const\n"
    "    gum::InfluenceDiagram< double >::cpt(std::string) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_utility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_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::Tensor< double > *) &((gum::InfluenceDiagram< double > const *)arg1)->utility(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_utility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  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_utility" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  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_utility" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::Tensor< double > *) &((gum::InfluenceDiagram< double > const *)arg1)->utility(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_utility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_utility", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_InfluenceDiagram_utility__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram_utility__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_utility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::utility(gum::NodeId) const\n"
    "    gum::InfluenceDiagram< double >::utility(std::string) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_isUtilityNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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_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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_isUtilityNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_isUtilityNode" "', 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_isUtilityNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_isUtilityNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)((gum::InfluenceDiagram< double > const *)arg1)->isUtilityNode((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_InfluenceDiagram_isUtilityNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_isUtilityNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_InfluenceDiagram_isUtilityNode__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram_isUtilityNode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_isUtilityNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::isUtilityNode(gum::NodeId) const\n"
    "    gum::InfluenceDiagram< double >::isUtilityNode(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_isDecisionNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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_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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_isDecisionNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_isDecisionNode" "', 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_isDecisionNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_isDecisionNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)((gum::InfluenceDiagram< double > const *)arg1)->isDecisionNode((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_InfluenceDiagram_isDecisionNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_isDecisionNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_InfluenceDiagram_isDecisionNode__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram_isDecisionNode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_isDecisionNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::isDecisionNode(gum::NodeId) const\n"
    "    gum::InfluenceDiagram< double >::isDecisionNode(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_isChanceNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  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_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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_isChanceNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_isChanceNode" "', 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_isChanceNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_isChanceNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)((gum::InfluenceDiagram< double > const *)arg1)->isChanceNode((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_InfluenceDiagram_isChanceNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_isChanceNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_InfluenceDiagram_isChanceNode__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram_isChanceNode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_isChanceNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::isChanceNode(gum::NodeId) const\n"
    "    gum::InfluenceDiagram< double >::isChanceNode(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_utilityNodeSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  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__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  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_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(SWIG_STD_MOVE(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_variable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  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_variable" "', 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_variable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_variable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::InfluenceDiagram< 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_InfluenceDiagram_variable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_variable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_InfluenceDiagram_variable__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram_variable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_variable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::variable(gum::NodeId) const\n"
    "    gum::InfluenceDiagram< double >::variable(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_nodeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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_addChanceNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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_addChanceNode__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::MultiDimImplementation< double > *arg3 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::MultiDimImplementation< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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_addUtilityNode__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::MultiDimImplementation< double > *arg3 = 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;
  
  (void)self;
  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_NullReferenceError, "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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::MultiDimImplementation< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  gum::NodeId result;
  
  (void)self;
  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_NullReferenceError, "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_add__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 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;
  
  (void)self;
  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);
  {
    std::string *ptr = (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_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_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 '" "InfluenceDiagram_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_InfluenceDiagram_add__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::NodeId result;
  
  (void)self;
  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);
  {
    std::string *ptr = (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_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->add((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_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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_InfluenceDiagram_add__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram_add__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    return _wrap_InfluenceDiagram_add__SWIG_0(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_InfluenceDiagram_add__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::InfluenceDiagram< double >::add(std::string const &,unsigned int)\n"
    "    gum::InfluenceDiagram< double >::add(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addChanceNode__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 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;
  
  (void)self;
  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);
  {
    std::string *ptr = (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_addChanceNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_addChanceNode" "', 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 '" "InfluenceDiagram_addChanceNode" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (arg1)->addChanceNode((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_InfluenceDiagram_addChanceNode__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::NodeId result;
  
  (void)self;
  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);
  {
    std::string *ptr = (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_addChanceNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_addChanceNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->addChanceNode((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_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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_InfluenceDiagram_addChanceNode__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram_addChanceNode__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_InfluenceDiagram_addChanceNode__SWIG_3(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_InfluenceDiagram_addChanceNode__SWIG_0(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_InfluenceDiagram_addChanceNode__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_InfluenceDiagram_addChanceNode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::InfluenceDiagram< double >::addChanceNode(std::string const &,unsigned int)\n"
    "    gum::InfluenceDiagram< double >::addChanceNode(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addUtilityNode__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::NodeId result;
  
  (void)self;
  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);
  {
    std::string *ptr = (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_addUtilityNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->addUtilityNode((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_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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_InfluenceDiagram_addUtilityNode__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram_addUtilityNode__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_InfluenceDiagram_addUtilityNode__SWIG_3(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_InfluenceDiagram_addUtilityNode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_InfluenceDiagram_addUtilityNode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::InfluenceDiagram< double >::addUtilityNode(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addDecisionNode__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 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;
  
  (void)self;
  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);
  {
    std::string *ptr = (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_addDecisionNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_addDecisionNode" "', 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 '" "InfluenceDiagram_addDecisionNode" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (arg1)->addDecisionNode((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_InfluenceDiagram_addDecisionNode__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::NodeId result;
  
  (void)self;
  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);
  {
    std::string *ptr = (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_addDecisionNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_addDecisionNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->addDecisionNode((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_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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_InfluenceDiagram_addDecisionNode__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram_addDecisionNode__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    return _wrap_InfluenceDiagram_addDecisionNode__SWIG_0(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_InfluenceDiagram_addDecisionNode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::InfluenceDiagram< double >::addDecisionNode(std::string const &,unsigned int)\n"
    "    gum::InfluenceDiagram< double >::addDecisionNode(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  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);
  {
    std::string *ptr = (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_erase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_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_InfluenceDiagram_erase__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_InfluenceDiagram_erase__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_InfluenceDiagram_erase__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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(std::string const &)\n"
    "    gum::InfluenceDiagram< double >::erase(gum::DiscreteVariable const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_changeVariableName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_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_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_changeVariableName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->changeVariableName(SWIG_STD_MOVE(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_changeVariableName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_changeVariableName" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  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_changeVariableName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_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 '" "InfluenceDiagram_changeVariableName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_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_InfluenceDiagram_changeVariableName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_changeVariableName", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_InfluenceDiagram_changeVariableName__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_InfluenceDiagram_changeVariableName__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_changeVariableName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::changeVariableName(gum::NodeId,std::string const &)\n"
    "    gum::InfluenceDiagram< double >::changeVariableName(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addArc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 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 ;
  
  (void)self;
  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_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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addArc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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_addArc" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  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_addArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_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 '" "InfluenceDiagram_addArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_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_InfluenceDiagram_addArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_addArc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_InfluenceDiagram_addArc__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_InfluenceDiagram_addArc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_addArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::addArc(gum::NodeId,gum::NodeId)\n"
    "    gum::InfluenceDiagram< double >::addArc(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_eraseArc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  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_NullReferenceError, "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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 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 ;
  
  (void)self;
  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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_eraseArc__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  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);
  {
    std::string *ptr = (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_eraseArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_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 '" "InfluenceDiagram_eraseArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_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_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) {
    PyObject *retobj = _wrap_InfluenceDiagram_eraseArc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_InfluenceDiagram_eraseArc__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_InfluenceDiagram_eraseArc__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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"
    "    gum::InfluenceDiagram< double >::eraseArc(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_decisionOrderExists(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DAG *result = 0 ;
  
  (void)self;
  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_decisionOrder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< std::size_t,std::allocator< std::size_t > > > result;
  
  (void)self;
  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_decisionOrder" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = ((gum::InfluenceDiagram< double > const *)arg1)->decisionOrder();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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_InfluenceDiagram_existsPathBetween__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 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 ;
  bool result;
  
  (void)self;
  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_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(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_existsPathBetween__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  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_existsPathBetween" "', 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_existsPathBetween" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_existsPathBetween" "', 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 '" "InfluenceDiagram_existsPathBetween" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_existsPathBetween" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (bool)((gum::InfluenceDiagram< double > const *)arg1)->existsPathBetween((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(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_InfluenceDiagram_existsPathBetween(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_existsPathBetween", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_InfluenceDiagram_existsPathBetween__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_InfluenceDiagram_existsPathBetween__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_existsPathBetween'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::existsPathBetween(gum::NodeId,gum::NodeId) const\n"
    "    gum::InfluenceDiagram< double >::existsPathBetween(std::string const &,std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_beginTopologyTransformation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_beginTopologyTransformation" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      (arg1)->beginTopologyTransformation();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_endTopologyTransformation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  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_endTopologyTransformation" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      (arg1)->endTopologyTransformation();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_names(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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_nodes" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_InfluenceDiagram_Sl_double_Sg__nodes((gum::InfluenceDiagram< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_arcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_InfluenceDiagram_Sl_double_Sg__arcs((gum::InfluenceDiagram< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_parents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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);
  arg2 = swig_obj[1];
  {
    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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  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);
  arg2 = swig_obj[1];
  {
    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_family(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_family", 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_family" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_InfluenceDiagram_Sl_double_Sg__family((gum::InfluenceDiagram< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_descendants(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_descendants", 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_descendants" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_InfluenceDiagram_Sl_double_Sg__descendants((gum::InfluenceDiagram< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_ancestors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_ancestors", 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_ancestors" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_InfluenceDiagram_Sl_double_Sg__ancestors((gum::InfluenceDiagram< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_moralizedAncestralGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::UndiGraph result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_moralizedAncestralGraph", 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_moralizedAncestralGraph" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_InfluenceDiagram_Sl_double_Sg__moralizedAncestralGraph(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_loadBIFXML__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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 *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  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,SWIG_STD_MOVE(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) {
    PyObject *retobj = _wrap_InfluenceDiagram_loadBIFXML__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_InfluenceDiagram_loadBIFXML__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  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,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  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 = NULL;
  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_ShaferShenoyLIMIDInference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::ShaferShenoyLIMIDInference< double > *result = 0 ;
  
  (void)self;
  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_ShaferShenoyLIMIDInference" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = (gum::ShaferShenoyLIMIDInference< double > *)new gum::ShaferShenoyLIMIDInference< double >((gum::InfluenceDiagram< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_junctionTree(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::JunctionTree *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_junctionTree" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      result = (gum::JunctionTree *)((gum::ShaferShenoyLIMIDInference< double > const *)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_ShaferShenoyLIMIDInference_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_clear" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_addNoForgettingAssumption__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::vector< gum::NodeId,std::allocator< gum::NodeId > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_addNoForgettingAssumption" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_addNoForgettingAssumption" "', argument " "2"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_addNoForgettingAssumption" "', 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 {
      (arg1)->addNoForgettingAssumption((std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_addNoForgettingAssumption__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_addNoForgettingAssumption" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_addNoForgettingAssumption" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_addNoForgettingAssumption" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->addNoForgettingAssumption((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_ShaferShenoyLIMIDInference_addNoForgettingAssumption(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyLIMIDInference_addNoForgettingAssumption", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      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) goto check_1;
    return _wrap_ShaferShenoyLIMIDInference_addNoForgettingAssumption__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_addNoForgettingAssumption__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyLIMIDInference_addNoForgettingAssumption'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyLIMIDInference< double >::addNoForgettingAssumption(std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::addNoForgettingAssumption(std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_hasNoForgettingAssumption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_hasNoForgettingAssumption" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      result = (bool)((gum::ShaferShenoyLIMIDInference< double > const *)arg1)->hasNoForgettingAssumption();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_reducedGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DAG result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_reducedGraph" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      result = ((gum::ShaferShenoyLIMIDInference< double > const *)arg1)->reducedGraph();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::DAG(result)), SWIGTYPE_p_gum__DAG, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_reversePartialOrder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< gum::Set< std::size_t >,std::allocator< gum::Set< std::size_t > > > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_reversePartialOrder" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      result = ((gum::ShaferShenoyLIMIDInference< double > const *)arg1)->reversePartialOrder();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< gum::NodeSet,std::allocator< gum::NodeSet > >(result)), SWIGTYPE_p_std__vectorT_gum__SetT_std__size_t_t_std__allocatorT_gum__SetT_std__size_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_reducedLIMID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::InfluenceDiagram< double > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_reducedLIMID" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      result = ((gum::ShaferShenoyLIMIDInference< double > const *)arg1)->reducedLIMID();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::InfluenceDiagram< double >(result)), SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_isSolvable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_isSolvable" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      result = (bool)((gum::ShaferShenoyLIMIDInference< double > const *)arg1)->isSolvable();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_optimalDecision__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_optimalDecision" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_optimalDecision" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (arg1)->optimalDecision(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_optimalDecision__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_optimalDecision" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_optimalDecision" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_optimalDecision" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->optimalDecision((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_optimalDecision(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyLIMIDInference_optimalDecision", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyLIMIDInference_optimalDecision__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_optimalDecision__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyLIMIDInference_optimalDecision'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyLIMIDInference< double >::optimalDecision(gum::NodeId)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::optimalDecision(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_posterior__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_posterior" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->posterior(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_posterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_posterior" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->posterior((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_posteriorUtility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_posteriorUtility" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_posteriorUtility" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->posteriorUtility(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_posteriorUtility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_posteriorUtility" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_posteriorUtility" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_posteriorUtility" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->posteriorUtility((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_posteriorUtility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyLIMIDInference_posteriorUtility", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyLIMIDInference_posteriorUtility__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_posteriorUtility__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyLIMIDInference_posteriorUtility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyLIMIDInference< double >::posteriorUtility(gum::NodeId)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::posteriorUtility(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_meanVar__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< std::pair< double,double > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_meanVar" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_meanVar" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (arg1)->meanVar(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj=PyAgrumHelper::PyDictFromPairMeanVar(result) ;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_meanVar__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< std::pair< double,double > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_meanVar" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_meanVar" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_meanVar" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->meanVar((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj=PyAgrumHelper::PyDictFromPairMeanVar(result) ;
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_MEU__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::pair< double,double > > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_MEU" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      result = (arg1)->MEU();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj=PyAgrumHelper::PyDictFromPairMeanVar(result) ;
  }
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_posterior__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_posterior" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_ShaferShenoyLIMIDInference_Sl_double_Sg__posterior__SWIG_2(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_posterior__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_posterior" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_ShaferShenoyLIMIDInference_Sl_double_Sg__posterior__SWIG_3(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_posterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyLIMIDInference_posterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyLIMIDInference_posterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_ShaferShenoyLIMIDInference_posterior__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_posterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_posterior__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyLIMIDInference_posterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyLIMIDInference< double >::posterior(gum::NodeId)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::posterior(std::string const &)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::posterior(gum::NodeId const)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::posterior(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_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 '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ShaferShenoyLIMIDInference_Sl_double_Sg__addEvidence__SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_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 '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ShaferShenoyLIMIDInference_Sl_double_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,SWIG_STD_MOVE(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_ShaferShenoyLIMIDInference_addEvidence__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_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 '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyLIMIDInference_Sl_double_Sg__addEvidence__SWIG_2(arg1,SWIG_STD_MOVE(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_ShaferShenoyLIMIDInference_addEvidence__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_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 '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyLIMIDInference_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_ShaferShenoyLIMIDInference_addEvidence__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_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 '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyLIMIDInference_Sl_double_Sg__addEvidence__SWIG_4(arg1,SWIG_STD_MOVE(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_ShaferShenoyLIMIDInference_addEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_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 '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyLIMIDInference_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_ShaferShenoyLIMIDInference_addEvidence__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_ShaferShenoyLIMIDInference_Sl_double_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyLIMIDInference_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_ShaferShenoyLIMIDInference_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_ShaferShenoyLIMIDInference_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_ShaferShenoyLIMIDInference_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_ShaferShenoyLIMIDInference_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_ShaferShenoyLIMIDInference_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyLIMIDInference_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyLIMIDInference< double >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_chgEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_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 '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ShaferShenoyLIMIDInference_Sl_double_Sg__chgEvidence__SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_chgEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_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 '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ShaferShenoyLIMIDInference_Sl_double_Sg__chgEvidence__SWIG_1(arg1,(std::string const &)*arg2,SWIG_STD_MOVE(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_ShaferShenoyLIMIDInference_chgEvidence__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_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 '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyLIMIDInference_Sl_double_Sg__chgEvidence__SWIG_2(arg1,SWIG_STD_MOVE(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_ShaferShenoyLIMIDInference_chgEvidence__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_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 '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyLIMIDInference_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_ShaferShenoyLIMIDInference_chgEvidence__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_ShaferShenoyLIMIDInference_Sl_double_Sg__chgEvidence__SWIG_4(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_chgEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_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 '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyLIMIDInference_Sl_double_Sg__chgEvidence__SWIG_5(arg1,SWIG_STD_MOVE(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_ShaferShenoyLIMIDInference_chgEvidence__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_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 '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyLIMIDInference_Sl_double_Sg__chgEvidence__SWIG_6(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_ShaferShenoyLIMIDInference_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyLIMIDInference_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_chgEvidence__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_ShaferShenoyLIMIDInference_chgEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_ShaferShenoyLIMIDInference_chgEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_ShaferShenoyLIMIDInference_chgEvidence__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_ShaferShenoyLIMIDInference_chgEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_ShaferShenoyLIMIDInference_chgEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_chgEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyLIMIDInference_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyLIMIDInference< double >::chgEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::chgEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::chgEvidence(gum::Tensor< double > const &)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::chgEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_hasEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_hasEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_ShaferShenoyLIMIDInference_Sl_double_Sg__hasEvidence__SWIG_0((gum::ShaferShenoyLIMIDInference< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_hasEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_hasEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ShaferShenoyLIMIDInference_Sl_double_Sg__hasEvidence__SWIG_1((gum::ShaferShenoyLIMIDInference< 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_ShaferShenoyLIMIDInference_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyLIMIDInference_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyLIMIDInference_hasEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_hasEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyLIMIDInference_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyLIMIDInference< double >::hasEvidence(gum::NodeId const) const\n"
    "    gum::ShaferShenoyLIMIDInference< double >::hasEvidence(std::string const &) const\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_eraseEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_eraseEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_ShaferShenoyLIMIDInference_Sl_double_Sg__eraseEvidence__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_eraseEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_eraseEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_ShaferShenoyLIMIDInference_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_ShaferShenoyLIMIDInference_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyLIMIDInference_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyLIMIDInference_eraseEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_eraseEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyLIMIDInference_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyLIMIDInference< double >::eraseEvidence(gum::NodeId const)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_hasSoftEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_hasSoftEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_ShaferShenoyLIMIDInference_Sl_double_Sg__hasSoftEvidence__SWIG_0((gum::ShaferShenoyLIMIDInference< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_hasHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyLIMIDInference_hasHardEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_hasHardEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ShaferShenoyLIMIDInference_Sl_double_Sg__hasHardEvidence((gum::ShaferShenoyLIMIDInference< 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_ShaferShenoyLIMIDInference_hasSoftEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_hasSoftEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< 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 '" "ShaferShenoyLIMIDInference_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyLIMIDInference_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ShaferShenoyLIMIDInference_Sl_double_Sg__hasSoftEvidence__SWIG_1((gum::ShaferShenoyLIMIDInference< 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_ShaferShenoyLIMIDInference_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyLIMIDInference_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyLIMIDInference_hasSoftEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_hasSoftEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyLIMIDInference_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyLIMIDInference< double >::hasSoftEvidence(gum::NodeId const) const\n"
    "    gum::ShaferShenoyLIMIDInference< double >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_nbrEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_nbrEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      result = gum_ShaferShenoyLIMIDInference_Sl_double_Sg__nbrEvidence((gum::ShaferShenoyLIMIDInference< 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_ShaferShenoyLIMIDInference_nbrHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_nbrHardEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      result = gum_ShaferShenoyLIMIDInference_Sl_double_Sg__nbrHardEvidence((gum::ShaferShenoyLIMIDInference< 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_ShaferShenoyLIMIDInference_nbrSoftEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_nbrSoftEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      result = gum_ShaferShenoyLIMIDInference_Sl_double_Sg__nbrSoftEvidence((gum::ShaferShenoyLIMIDInference< 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_ShaferShenoyLIMIDInference_influenceDiagram(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::InfluenceDiagram< double > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_influenceDiagram" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      result = (gum::InfluenceDiagram< double > *) &gum_ShaferShenoyLIMIDInference_Sl_double_Sg__influenceDiagram((gum::ShaferShenoyLIMIDInference< 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_ShaferShenoyLIMIDInference_setEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyLIMIDInference_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_setEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ShaferShenoyLIMIDInference_Sl_double_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_updateEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyLIMIDInference_updateEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_updateEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ShaferShenoyLIMIDInference_Sl_double_Sg__updateEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_hardEvidenceNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_hardEvidenceNodes" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ShaferShenoyLIMIDInference_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_softEvidenceNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_softEvidenceNodes" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ShaferShenoyLIMIDInference_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_MEU__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_MEU" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ShaferShenoyLIMIDInference_Sl_double_Sg__MEU__SWIG_1(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_MEU(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyLIMIDInference_MEU", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_MEU__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_MEU__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyLIMIDInference_MEU'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyLIMIDInference< double >::MEU()\n"
    "    gum::ShaferShenoyLIMIDInference< double >::MEU()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_meanVar__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyLIMIDInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyLIMIDInference_meanVar" "', argument " "1"" of type '" "gum::ShaferShenoyLIMIDInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyLIMIDInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyLIMIDInference_meanVar" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_ShaferShenoyLIMIDInference_Sl_double_Sg__meanVar__SWIG_2(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyLIMIDInference_meanVar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyLIMIDInference_meanVar", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyLIMIDInference_meanVar__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_ShaferShenoyLIMIDInference_meanVar__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyLIMIDInference_meanVar__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyLIMIDInference_meanVar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyLIMIDInference< double >::meanVar(gum::NodeId)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::meanVar(std::string const &)\n"
    "    gum::ShaferShenoyLIMIDInference< double >::meanVar(gum::NodeId)\n");
  return 0;
}


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

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

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


SWIGINTERN PyObject *_wrap_IMarkovRandomField_factor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_factor" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< 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 '" "IMarkovRandomField_factor" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IMarkovRandomField_factor" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeSet * >(argp2);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::IMarkovRandomField< double > const *)arg1)->factor((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_smallestFactorFromNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::NodeSet *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_smallestFactorFromNode" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IMarkovRandomField_smallestFactorFromNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::NodeSet *) &((gum::IMarkovRandomField< double > const *)arg1)->smallestFactorFromNode(SWIG_STD_MOVE(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_IMarkovRandomField_smallestFactorFromNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::NodeSet *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_smallestFactorFromNode" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< 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 '" "IMarkovRandomField_smallestFactorFromNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IMarkovRandomField_smallestFactorFromNode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::NodeSet *) &((gum::IMarkovRandomField< double > const *)arg1)->smallestFactorFromNode((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_IMarkovRandomField_smallestFactorFromNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IMarkovRandomField_smallestFactorFromNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_IMarkovRandomField_smallestFactorFromNode__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_IMarkovRandomField_smallestFactorFromNode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IMarkovRandomField_smallestFactorFromNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::IMarkovRandomField< double >::smallestFactorFromNode(gum::NodeId) const\n"
    "    gum::IMarkovRandomField< double >::smallestFactorFromNode(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_factors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::FactorTable< double > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_factors" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = (gum::FactorTable< double > *) &((gum::IMarkovRandomField< double > const *)arg1)->factors();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyList_New(0);
    
    PyObject* pyval;
    for (auto kv : *result) {
      pyval=PyAgrumHelper::PySetFromNodeSet(kv.first);
      PyList_Append(resultobj, pyval);
      Py_DecRef(pyval);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_variableNodeMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VariableNodeMap *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_variableNodeMap" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = (gum::VariableNodeMap *) &((gum::IMarkovRandomField< 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_IMarkovRandomField_variable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IMarkovRandomField_variable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_variable" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IMarkovRandomField_variable" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::IMarkovRandomField< double > const *)arg1)->variable(SWIG_STD_MOVE(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_IMarkovRandomField_nodeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IMarkovRandomField_nodeId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_nodeId" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< 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 '" "IMarkovRandomField_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IMarkovRandomField_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = ((gum::IMarkovRandomField< 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_IMarkovRandomField_idFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IMarkovRandomField_idFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_idFromName" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< 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 '" "IMarkovRandomField_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IMarkovRandomField_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::IMarkovRandomField< 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_IMarkovRandomField_variableFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IMarkovRandomField_variableFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_variableFromName" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< 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 '" "IMarkovRandomField_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IMarkovRandomField_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::IMarkovRandomField< 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_IMarkovRandomField___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  gum::IMarkovRandomField< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IMarkovRandomField___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField___eq__" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IMarkovRandomField___eq__" "', argument " "2"" of type '" "gum::IMarkovRandomField< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IMarkovRandomField___eq__" "', argument " "2"" of type '" "gum::IMarkovRandomField< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp2);
  {
    try {
      result = (bool)((gum::IMarkovRandomField< double > const *)arg1)->operator ==((gum::IMarkovRandomField< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  gum::IMarkovRandomField< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IMarkovRandomField___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField___ne__" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IMarkovRandomField___ne__" "', argument " "2"" of type '" "gum::IMarkovRandomField< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IMarkovRandomField___ne__" "', argument " "2"" of type '" "gum::IMarkovRandomField< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp2);
  {
    try {
      result = (bool)((gum::IMarkovRandomField< double > const *)arg1)->operator !=((gum::IMarkovRandomField< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_dim(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_dim" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = ((gum::IMarkovRandomField< 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_IMarkovRandomField_maxVarDomainSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_maxVarDomainSize" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = ((gum::IMarkovRandomField< 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_IMarkovRandomField_minParam(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_minParam" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = (double)((gum::IMarkovRandomField< double > const *)arg1)->minParam();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_maxParam(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_maxParam" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = (double)((gum::IMarkovRandomField< double > const *)arg1)->maxParam();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_minNonZeroParam(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_minNonZeroParam" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = (double)((gum::IMarkovRandomField< double > const *)arg1)->minNonZeroParam();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_maxNonOneParam(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_maxNonOneParam" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = (double)((gum::IMarkovRandomField< double > const *)arg1)->maxNonOneParam();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_toDot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_toDot" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = ((gum::IMarkovRandomField< 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_IMarkovRandomField_toDotAsFactorGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_toDotAsFactorGraph" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = ((gum::IMarkovRandomField< double > const *)arg1)->toDotAsFactorGraph();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_minimalCondSet__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 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;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_minimalCondSet" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IMarkovRandomField_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 '" "IMarkovRandomField_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IMarkovRandomField_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = ((gum::IMarkovRandomField< double > const *)arg1)->minimalCondSet(SWIG_STD_MOVE(arg2),(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_minimalCondSet__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 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;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_minimalCondSet" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< 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 '" "IMarkovRandomField_minimalCondSet" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IMarkovRandomField_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 '" "IMarkovRandomField_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IMarkovRandomField_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = ((gum::IMarkovRandomField< double > const *)arg1)->minimalCondSet((gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(result)), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_names(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_names" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_IMarkovRandomField_Sl_double_Sg__names((gum::IMarkovRandomField< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_nodes" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_IMarkovRandomField_Sl_double_Sg__nodes((gum::IMarkovRandomField< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_neighbours(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IMarkovRandomField_neighbours", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_neighbours" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_IMarkovRandomField_Sl_double_Sg__neighbours((gum::IMarkovRandomField< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_edges" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_IMarkovRandomField_Sl_double_Sg__edges((gum::IMarkovRandomField< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_minimalCondSet__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_minimalCondSet" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IMarkovRandomField_minimalCondSet" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = (PyObject *)gum_IMarkovRandomField_Sl_double_Sg__minimalCondSet__SWIG_2((gum::IMarkovRandomField< double > const *)arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_minimalCondSet__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_minimalCondSet" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (PyObject *)gum_IMarkovRandomField_Sl_double_Sg__minimalCondSet__SWIG_3((gum::IMarkovRandomField< double > const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_minimalCondSet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IMarkovRandomField_minimalCondSet", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      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) goto check_1;
    {
      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) goto check_1;
    return _wrap_IMarkovRandomField_minimalCondSet__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      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) goto check_2;
    return _wrap_IMarkovRandomField_minimalCondSet__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_IMarkovRandomField_minimalCondSet__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_IMarkovRandomField_minimalCondSet__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IMarkovRandomField_minimalCondSet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::IMarkovRandomField< double >::minimalCondSet(gum::NodeId,gum::NodeSet const &) const\n"
    "    gum::IMarkovRandomField< double >::minimalCondSet(gum::NodeSet const &,gum::NodeSet const &) const\n"
    "    gum::IMarkovRandomField< double >::minimalCondSet(gum::NodeId,PyObject *) const\n"
    "    gum::IMarkovRandomField< double >::minimalCondSet(PyObject *,PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_factor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_factor" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (gum::Tensor< double > *) &gum_IMarkovRandomField_Sl_double_Sg__factor__SWIG_1((gum::IMarkovRandomField< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_factor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IMarkovRandomField_factor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      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) goto check_1;
    return _wrap_IMarkovRandomField_factor__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_IMarkovRandomField_factor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IMarkovRandomField_factor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::IMarkovRandomField< double >::factor(gum::NodeSet const &) const\n"
    "    gum::IMarkovRandomField< double >::factor(PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_isIndependent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_isIndependent" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  arg4 = swig_obj[3];
  {
    try {
      result = (bool)gum_IMarkovRandomField_Sl_double_Sg__isIndependent__SWIG_0(arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_isIndependent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField_isIndependent" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (bool)gum_IMarkovRandomField_Sl_double_Sg__isIndependent__SWIG_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField_isIndependent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IMarkovRandomField_isIndependent", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_IMarkovRandomField_isIndependent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_IMarkovRandomField_isIndependent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IMarkovRandomField_isIndependent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::IMarkovRandomField< double >::isIndependent(PyObject *,PyObject *,PyObject *)\n"
    "    gum::IMarkovRandomField< double >::isIndependent(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IMarkovRandomField___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField___repr__" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = gum_IMarkovRandomField_Sl_double_Sg____repr__((gum::IMarkovRandomField< 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_IMarkovRandomField___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMarkovRandomField___str__" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = gum_IMarkovRandomField_Sl_double_Sg____str__((gum::IMarkovRandomField< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_MarkovRandomField_fastPrototype__SWIG_0(PyObject *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::MarkovRandomField< double > result;
  
  (void)self;
  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 '" "MarkovRandomField_fastPrototype" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_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 '" "MarkovRandomField_fastPrototype" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = gum::MarkovRandomField< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype((std::string const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::MarkovRandomField< double >(result)), SWIGTYPE_p_gum__MarkovRandomFieldT_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_MarkovRandomField_fastPrototype__SWIG_1(PyObject *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::MarkovRandomField< double > result;
  
  (void)self;
  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 '" "MarkovRandomField_fastPrototype" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_fastPrototype" "', 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 '" "MarkovRandomField_fastPrototype" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_fastPrototype" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum::MarkovRandomField< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::MarkovRandomField< double >(result)), SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, SWIG_POINTER_OWN |  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_MarkovRandomField_fastPrototype__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::MarkovRandomField< double > result;
  
  (void)self;
  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 '" "MarkovRandomField_fastPrototype" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_fastPrototype" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = gum::MarkovRandomField< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::MarkovRandomField< double >(result)), SWIGTYPE_p_gum__MarkovRandomFieldT_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_MarkovRandomField_fastPrototype(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField_fastPrototype", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_MarkovRandomField_fastPrototype__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_MarkovRandomField_fastPrototype__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovRandomField_fastPrototype__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MarkovRandomField_fastPrototype'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::fastPrototype(std::string const &,gum::Size)\n"
    "    gum::MarkovRandomField< double >::fastPrototype(std::string const &,std::string const &)\n"
    "    gum::MarkovRandomField< double >::fastPrototype(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_fromBN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::MarkovRandomField< double > result;
  
  (void)self;
  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 '" "MarkovRandomField_fromBN" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_fromBN" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      result = gum::MarkovRandomField< double >::SWIGTEMPLATEDISAMBIGUATOR fromBN((gum::BayesNet< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::MarkovRandomField< double >(result)), SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_MarkovRandomField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::MarkovRandomField< double > *result = 0 ;
  
  (void)self;
  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_MarkovRandomField" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::MarkovRandomField< double > *)new gum::MarkovRandomField< double >(SWIG_STD_MOVE(arg1));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


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


SWIGINTERN PyObject *_wrap_new_MarkovRandomField(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MarkovRandomField", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_MarkovRandomField__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_MarkovRandomField__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_MarkovRandomField__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MarkovRandomField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::MarkovRandomField()\n"
    "    gum::MarkovRandomField< double >::MarkovRandomField(std::string)\n"
    "    gum::MarkovRandomField< double >::MarkovRandomField(gum::MarkovRandomField< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_factor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_factor" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_factor" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_factor" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeSet * >(argp2);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::MarkovRandomField< double > const *)arg1)->factor((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_factor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_factor" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_factor" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_factor" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< double > *) &((gum::MarkovRandomField< double > const *)arg1)->factor((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_smallestFactorFromNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MarkovRandomField_smallestFactorFromNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_smallestFactorFromNode" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkovRandomField_smallestFactorFromNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::NodeSet *) &((gum::MarkovRandomField< double > const *)arg1)->smallestFactorFromNode(SWIG_STD_MOVE(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_MarkovRandomField_factors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::FactorTable< double > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_factors" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  {
    try {
      result = (gum::FactorTable< double > *) &((gum::MarkovRandomField< double > const *)arg1)->factors();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyList_New(0);
    
    PyObject* pyval;
    for (auto kv : *result) {
      pyval=PyAgrumHelper::PySetFromNodeSet(kv.first);
      PyList_Append(resultobj, pyval);
      Py_DecRef(pyval);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_variableNodeMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VariableNodeMap *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_variableNodeMap" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  {
    try {
      result = (gum::VariableNodeMap *) &((gum::MarkovRandomField< 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_MarkovRandomField_add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_add" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_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_MarkovRandomField_add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 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;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_add" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_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 '" "MarkovRandomField_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_MarkovRandomField_add__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::NodeId result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_add" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->add((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_MarkovRandomField_add__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 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;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_add" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_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 '" "MarkovRandomField_add" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (arg1)->add((gum::DiscreteVariable const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField_add", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_MarkovRandomField_add__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovRandomField_add__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    return _wrap_MarkovRandomField_add__SWIG_3(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_MarkovRandomField_add__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MarkovRandomField_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::add(gum::DiscreteVariable const &)\n"
    "    gum::MarkovRandomField< double >::add(std::string const &,unsigned int)\n"
    "    gum::MarkovRandomField< double >::add(std::string const &)\n"
    "    gum::MarkovRandomField< double >::add(gum::DiscreteVariable const &,gum::NodeId)\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_MarkovRandomField_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_erase" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkovRandomField_erase" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      (arg1)->erase(SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_erase" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_erase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_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_MarkovRandomField_erase__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_erase" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_erase" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_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_MarkovRandomField_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField_erase", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_MarkovRandomField_erase__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_MarkovRandomField_erase__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovRandomField_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MarkovRandomField_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::erase(gum::NodeId)\n"
    "    gum::MarkovRandomField< double >::erase(std::string const &)\n"
    "    gum::MarkovRandomField< double >::erase(gum::DiscreteVariable const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_variable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_variable" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkovRandomField_variable" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::MarkovRandomField< double > const *)arg1)->variable(SWIG_STD_MOVE(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_MarkovRandomField_variable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_variable" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_variable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_variable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::MarkovRandomField< 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_MarkovRandomField_variable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField_variable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_MarkovRandomField_variable__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovRandomField_variable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MarkovRandomField_variable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::variable(gum::NodeId) const\n"
    "    gum::MarkovRandomField< double >::variable(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_changeVariableName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_changeVariableName" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkovRandomField_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 '" "MarkovRandomField_changeVariableName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_changeVariableName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->changeVariableName(SWIG_STD_MOVE(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_MarkovRandomField_changeVariableName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_changeVariableName" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_changeVariableName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_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 '" "MarkovRandomField_changeVariableName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_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_MarkovRandomField_changeVariableName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField_changeVariableName", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_MarkovRandomField_changeVariableName__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_MarkovRandomField_changeVariableName__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MarkovRandomField_changeVariableName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::changeVariableName(gum::NodeId,std::string const &)\n"
    "    gum::MarkovRandomField< double >::changeVariableName(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_changeVariableLabel__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_changeVariableLabel" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkovRandomField_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 '" "MarkovRandomField_changeVariableLabel" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_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 '" "MarkovRandomField_changeVariableLabel" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_changeVariableLabel" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      (arg1)->changeVariableLabel(SWIG_STD_MOVE(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_MarkovRandomField_changeVariableLabel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_changeVariableLabel" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_changeVariableLabel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_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 '" "MarkovRandomField_changeVariableLabel" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_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 '" "MarkovRandomField_changeVariableLabel" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_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_MarkovRandomField_changeVariableLabel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField_changeVariableLabel", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_MarkovRandomField_changeVariableLabel__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_MarkovRandomField_changeVariableLabel__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MarkovRandomField_changeVariableLabel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::changeVariableLabel(gum::NodeId,std::string const &,std::string const &)\n"
    "    gum::MarkovRandomField< double >::changeVariableLabel(std::string const &,std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_nodeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MarkovRandomField_nodeId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_nodeId" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = ((gum::MarkovRandomField< 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_MarkovRandomField_idFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MarkovRandomField_idFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_idFromName" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::MarkovRandomField< 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_MarkovRandomField_variableFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MarkovRandomField_variableFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_variableFromName" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::MarkovRandomField< 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_MarkovRandomField_addFactor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_addFactor" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_addFactor" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_addFactor" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->addFactor((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_addFactor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_addFactor" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_addFactor" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_addFactor" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeSet * >(argp2);
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->addFactor((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_addFactor__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_addFactor" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkovRandomField_addFactor" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_addFactor" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      result = (gum::Tensor< double > *) &(arg1)->addFactor((gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_eraseFactor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_eraseFactor" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_eraseFactor" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_eraseFactor" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeSet * >(argp2);
  {
    try {
      (arg1)->eraseFactor((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_eraseFactor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_eraseFactor" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_eraseFactor" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_eraseFactor" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->eraseFactor((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_MarkovRandomField_generateFactors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_generateFactors" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  {
    try {
      ((gum::MarkovRandomField< double > const *)arg1)->generateFactors();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_generateFactor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MarkovRandomField_generateFactor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_generateFactor" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_generateFactor" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_generateFactor" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeSet * >(argp2);
  {
    try {
      ((gum::MarkovRandomField< double > const *)arg1)->generateFactor((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_beginTopologyTransformation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_beginTopologyTransformation" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  {
    try {
      (arg1)->beginTopologyTransformation();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_endTopologyTransformation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_endTopologyTransformation" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  {
    try {
      (arg1)->endTopologyTransformation();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_graph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::UndiGraph *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_graph" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  {
    try {
      result = (gum::UndiGraph *) &((gum::MarkovRandomField< double > const *)arg1)->graph();
    } 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_MarkovRandomField_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_size" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  {
    try {
      result = ((gum::MarkovRandomField< 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_MarkovRandomField_log10DomainSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_log10DomainSize" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  {
    try {
      result = (double)((gum::MarkovRandomField< double > const *)arg1)->log10DomainSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_names(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_names" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_MarkovRandomField_Sl_double_Sg__names((gum::MarkovRandomField< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_nodes" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_MarkovRandomField_Sl_double_Sg__nodes((gum::MarkovRandomField< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_neighbours(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MarkovRandomField_neighbours", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_neighbours" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_MarkovRandomField_Sl_double_Sg__neighbours((gum::MarkovRandomField< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_edges" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_MarkovRandomField_Sl_double_Sg__edges((gum::MarkovRandomField< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_minimalCondSet__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_minimalCondSet" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkovRandomField_minimalCondSet" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = (PyObject *)gum_MarkovRandomField_Sl_double_Sg__minimalCondSet__SWIG_0((gum::MarkovRandomField< double > const *)arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_minimalCondSet__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_minimalCondSet" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (PyObject *)gum_MarkovRandomField_Sl_double_Sg__minimalCondSet__SWIG_1((gum::MarkovRandomField< double > const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_minimalCondSet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField_minimalCondSet", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_MarkovRandomField_minimalCondSet__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_MarkovRandomField_minimalCondSet__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MarkovRandomField_minimalCondSet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::minimalCondSet(gum::NodeId,PyObject *) const\n"
    "    gum::MarkovRandomField< double >::minimalCondSet(PyObject *,PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_factor__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_factor" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (gum::Tensor< double > *) &gum_MarkovRandomField_Sl_double_Sg__factor__SWIG_2((gum::MarkovRandomField< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_factor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField_factor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      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) goto check_1;
    return _wrap_MarkovRandomField_factor__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_MarkovRandomField_factor__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovRandomField_factor__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MarkovRandomField_factor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::factor(gum::NodeSet const &) const\n"
    "    gum::MarkovRandomField< double >::factor(std::vector< std::string,std::allocator< std::string > > const &) const\n"
    "    gum::MarkovRandomField< double >::factor(PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_isIndependent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_isIndependent" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  arg4 = swig_obj[3];
  {
    try {
      result = (bool)gum_MarkovRandomField_Sl_double_Sg__isIndependent__SWIG_0(arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_isIndependent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_isIndependent" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (bool)gum_MarkovRandomField_Sl_double_Sg__isIndependent__SWIG_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_isIndependent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField_isIndependent", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_MarkovRandomField_isIndependent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_MarkovRandomField_isIndependent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MarkovRandomField_isIndependent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::isIndependent(PyObject *,PyObject *,PyObject *)\n"
    "    gum::MarkovRandomField< double >::isIndependent(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_loadUAI__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::string arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_loadUAI" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_loadUAI" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  arg3 = swig_obj[2];
  {
    try {
      result = gum_MarkovRandomField_Sl_double_Sg__loadUAI__SWIG_0(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_loadUAI__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_loadUAI" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_loadUAI" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_MarkovRandomField_Sl_double_Sg__loadUAI__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_loadUAI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField_loadUAI", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovRandomField_loadUAI__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_MarkovRandomField_loadUAI__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MarkovRandomField_loadUAI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::loadUAI(std::string,PyObject *)\n"
    "    gum::MarkovRandomField< double >::loadUAI(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_saveUAI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MarkovRandomField_saveUAI", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_saveUAI" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< 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 '" "MarkovRandomField_saveUAI" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_MarkovRandomField_Sl_double_Sg__saveUAI(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField___repr__" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  {
    try {
      result = gum_MarkovRandomField_Sl_double_Sg____repr__((gum::MarkovRandomField< 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_MarkovRandomField___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField___str__" "', argument " "1"" of type '" "gum::MarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  {
    try {
      result = gum_MarkovRandomField_Sl_double_Sg____str__((gum::MarkovRandomField< 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_MarkovRandomField_addFactor__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_addFactor" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (gum::Tensor< double > *) &gum_MarkovRandomField_Sl_double_Sg__addFactor__SWIG_3(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TensorT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_addFactor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField_addFactor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      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) goto check_1;
    return _wrap_MarkovRandomField_addFactor__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_MarkovRandomField_addFactor__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_MarkovRandomField_addFactor__SWIG_0(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovRandomField_addFactor__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MarkovRandomField_addFactor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::addFactor(std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::MarkovRandomField< double >::addFactor(gum::NodeSet const &)\n"
    "    gum::MarkovRandomField< double >::addFactor(gum::Tensor< double > const &)\n"
    "    gum::MarkovRandomField< double >::addFactor(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_eraseFactor__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_eraseFactor" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_MarkovRandomField_Sl_double_Sg__eraseFactor__SWIG_2(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_eraseFactor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField_eraseFactor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      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) goto check_1;
    return _wrap_MarkovRandomField_eraseFactor__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_MarkovRandomField_eraseFactor__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovRandomField_eraseFactor__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MarkovRandomField_eraseFactor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::eraseFactor(gum::NodeSet const &)\n"
    "    gum::MarkovRandomField< double >::eraseFactor(std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::MarkovRandomField< double >::eraseFactor(PyObject *)\n");
  return 0;
}


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

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

SWIGINTERN PyObject *_wrap_new_ShaferShenoyMRFInference__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  gum::ShaferShenoyMRFInference< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaferShenoyMRFInference" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShaferShenoyMRFInference" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::ShaferShenoyMRFInference< double > *)new gum::ShaferShenoyMRFInference< double >((gum::IMarkovRandomField< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShaferShenoyMRFInference__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IMarkovRandomField< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::ShaferShenoyMRFInference< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaferShenoyMRFInference" "', argument " "1"" of type '" "gum::IMarkovRandomField< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IMarkovRandomField< double > * >(argp1);
  {
    try {
      result = (gum::ShaferShenoyMRFInference< double > *)new gum::ShaferShenoyMRFInference< double >((gum::IMarkovRandomField< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShaferShenoyMRFInference(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ShaferShenoyMRFInference", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_ShaferShenoyMRFInference__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_ShaferShenoyMRFInference__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ShaferShenoyMRFInference'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyMRFInference< double >::ShaferShenoyMRFInference(gum::IMarkovRandomField< double > const *,bool)\n"
    "    gum::ShaferShenoyMRFInference< double >::ShaferShenoyMRFInference(gum::IMarkovRandomField< double > const *)\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_setTriangulation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  gum::Triangulation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_setTriangulation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_setTriangulation" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_setTriangulation" "', argument " "2"" of type '" "gum::Triangulation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_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_ShaferShenoyMRFInference_joinTree(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::JoinTree *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_joinTree" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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_ShaferShenoyMRFInference_junctionTree(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::JunctionTree *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_junctionTree" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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_ShaferShenoyMRFInference_evidenceProbability(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_evidenceProbability" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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_ShaferShenoyMRFInference_setNumberOfThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_setNumberOfThreads", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_setNumberOfThreads" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_setNumberOfThreads" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__setNumberOfThreads(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_getNumberOfThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_getNumberOfThreads" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  {
    try {
      result = (int)gum_ShaferShenoyMRFInference_Sl_double_Sg__getNumberOfThreads(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_isGumNumberOfThreadsOverriden(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_isGumNumberOfThreadsOverriden" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  {
    try {
      result = (bool)gum_ShaferShenoyMRFInference_Sl_double_Sg__isGumNumberOfThreadsOverriden(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_setMaxMemory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_setMaxMemory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_setMaxMemory" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_setMaxMemory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__setMaxMemory(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_posterior__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_posterior" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_ShaferShenoyMRFInference_Sl_double_Sg__posterior__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_posterior__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_posterior" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_posterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_ShaferShenoyMRFInference_Sl_double_Sg__posterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_addEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_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 '" "ShaferShenoyMRFInference_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__addEvidence__SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_addEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_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 '" "ShaferShenoyMRFInference_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,SWIG_STD_MOVE(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_ShaferShenoyMRFInference_addEvidence__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_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 '" "ShaferShenoyMRFInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__addEvidence__SWIG_2(arg1,SWIG_STD_MOVE(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_ShaferShenoyMRFInference_addEvidence__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_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 '" "ShaferShenoyMRFInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyMRFInference_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_ShaferShenoyMRFInference_addEvidence__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_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 '" "ShaferShenoyMRFInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__addEvidence__SWIG_4(arg1,SWIG_STD_MOVE(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_ShaferShenoyMRFInference_addEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_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 '" "ShaferShenoyMRFInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyMRFInference_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_ShaferShenoyMRFInference_addEvidence__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyMRFInference_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_addEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__addEvidence__SWIG_6(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_addEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_ShaferShenoyMRFInference_addEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_ShaferShenoyMRFInference_addEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_ShaferShenoyMRFInference_addEvidence__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_ShaferShenoyMRFInference_addEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_ShaferShenoyMRFInference_addEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_addEvidence__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyMRFInference_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyMRFInference< double >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::ShaferShenoyMRFInference< double >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::ShaferShenoyMRFInference< double >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::ShaferShenoyMRFInference< double >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::ShaferShenoyMRFInference< double >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::ShaferShenoyMRFInference< double >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::ShaferShenoyMRFInference< double >::addEvidence(gum::Tensor< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_chgEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_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 '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__chgEvidence__SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_chgEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_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 '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__chgEvidence__SWIG_1(arg1,(std::string const &)*arg2,SWIG_STD_MOVE(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_ShaferShenoyMRFInference_chgEvidence__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_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 '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__chgEvidence__SWIG_2(arg1,SWIG_STD_MOVE(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_ShaferShenoyMRFInference_chgEvidence__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_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 '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyMRFInference_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_ShaferShenoyMRFInference_chgEvidence__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  gum::Tensor< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__TensorT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "2"" of type '" "gum::Tensor< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Tensor< double > * >(argp2);
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__chgEvidence__SWIG_4(arg1,(gum::Tensor< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_chgEvidence__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_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 '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__chgEvidence__SWIG_5(arg1,SWIG_STD_MOVE(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_ShaferShenoyMRFInference_chgEvidence__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_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 '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__chgEvidence__SWIG_6(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_ShaferShenoyMRFInference_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_chgEvidence__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_ShaferShenoyMRFInference_chgEvidence__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_ShaferShenoyMRFInference_chgEvidence__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_ShaferShenoyMRFInference_chgEvidence__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_ShaferShenoyMRFInference_chgEvidence__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap_ShaferShenoyMRFInference_chgEvidence__SWIG_3(self, argc, argv);
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_chgEvidence__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyMRFInference_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyMRFInference< double >::chgEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::ShaferShenoyMRFInference< double >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::ShaferShenoyMRFInference< double >::chgEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::ShaferShenoyMRFInference< double >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::ShaferShenoyMRFInference< double >::chgEvidence(gum::Tensor< double > const &)\n"
    "    gum::ShaferShenoyMRFInference< double >::chgEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::ShaferShenoyMRFInference< double >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_hasEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_hasEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_ShaferShenoyMRFInference_Sl_double_Sg__hasEvidence__SWIG_0((gum::ShaferShenoyMRFInference< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_hasEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_hasEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ShaferShenoyMRFInference_Sl_double_Sg__hasEvidence__SWIG_1((gum::ShaferShenoyMRFInference< 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_ShaferShenoyMRFInference_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyMRFInference_hasEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_hasEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyMRFInference_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyMRFInference< double >::hasEvidence(gum::NodeId const) const\n"
    "    gum::ShaferShenoyMRFInference< double >::hasEvidence(std::string const &) const\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_eraseEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_eraseEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__eraseEvidence__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_eraseEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_eraseEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_ShaferShenoyMRFInference_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_ShaferShenoyMRFInference_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyMRFInference_eraseEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_eraseEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyMRFInference_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyMRFInference< double >::eraseEvidence(gum::NodeId const)\n"
    "    gum::ShaferShenoyMRFInference< double >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_hasSoftEvidence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_hasSoftEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_ShaferShenoyMRFInference_Sl_double_Sg__hasSoftEvidence__SWIG_0((gum::ShaferShenoyMRFInference< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_hasHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_hasHardEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_hasHardEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ShaferShenoyMRFInference_Sl_double_Sg__hasHardEvidence((gum::ShaferShenoyMRFInference< 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_ShaferShenoyMRFInference_hasSoftEvidence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_hasSoftEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ShaferShenoyMRFInference_Sl_double_Sg__hasSoftEvidence__SWIG_1((gum::ShaferShenoyMRFInference< 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_ShaferShenoyMRFInference_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyMRFInference_hasSoftEvidence__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_hasSoftEvidence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyMRFInference_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyMRFInference< double >::hasSoftEvidence(gum::NodeId const) const\n"
    "    gum::ShaferShenoyMRFInference< double >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_nbrEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_nbrEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  {
    try {
      result = gum_ShaferShenoyMRFInference_Sl_double_Sg__nbrEvidence((gum::ShaferShenoyMRFInference< 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_ShaferShenoyMRFInference_nbrHardEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_nbrHardEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  {
    try {
      result = gum_ShaferShenoyMRFInference_Sl_double_Sg__nbrHardEvidence((gum::ShaferShenoyMRFInference< 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_ShaferShenoyMRFInference_nbrSoftEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_nbrSoftEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  {
    try {
      result = gum_ShaferShenoyMRFInference_Sl_double_Sg__nbrSoftEvidence((gum::ShaferShenoyMRFInference< 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_ShaferShenoyMRFInference_eraseAllTargets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_eraseAllTargets" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__eraseAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_addTarget__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_addTarget" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_addTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__addTarget__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_addTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_addTarget" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_ShaferShenoyMRFInference_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_ShaferShenoyMRFInference_addTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_addTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyMRFInference_addTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_addTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyMRFInference_addTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyMRFInference< double >::addTarget(gum::NodeId const)\n"
    "    gum::ShaferShenoyMRFInference< double >::addTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_eraseTarget__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_eraseTarget" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_eraseTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__eraseTarget__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_eraseTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_eraseTarget" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_ShaferShenoyMRFInference_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_ShaferShenoyMRFInference_eraseTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_eraseTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyMRFInference_eraseTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_eraseTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyMRFInference_eraseTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyMRFInference< double >::eraseTarget(gum::NodeId const)\n"
    "    gum::ShaferShenoyMRFInference< double >::eraseTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_isTarget__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_isTarget" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_isTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_ShaferShenoyMRFInference_Sl_double_Sg__isTarget__SWIG_0((gum::ShaferShenoyMRFInference< double > const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_isTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_isTarget" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ShaferShenoyMRFInference_Sl_double_Sg__isTarget__SWIG_1((gum::ShaferShenoyMRFInference< 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_ShaferShenoyMRFInference_isTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_isTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyMRFInference_isTarget__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_isTarget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyMRFInference_isTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyMRFInference< double >::isTarget(gum::NodeId const) const\n"
    "    gum::ShaferShenoyMRFInference< double >::isTarget(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_nbrTargets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_nbrTargets" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  {
    try {
      result = gum_ShaferShenoyMRFInference_Sl_double_Sg__nbrTargets((gum::ShaferShenoyMRFInference< 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_ShaferShenoyMRFInference_H__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_H" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_H" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (double)gum_ShaferShenoyMRFInference_Sl_double_Sg__H__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_H__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_H" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_ShaferShenoyMRFInference_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_ShaferShenoyMRFInference_H(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_H", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyMRFInference_H__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_H__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyMRFInference_H'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyMRFInference< double >::H(gum::NodeId const)\n"
    "    gum::ShaferShenoyMRFInference< double >::H(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_evidenceImpact__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_evidenceImpact" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyMRFInference_evidenceImpact" "', 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 '" "ShaferShenoyMRFInference_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_evidenceImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_ShaferShenoyMRFInference_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_evidenceImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_evidenceImpact" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_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 '" "ShaferShenoyMRFInference_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_ShaferShenoyMRFInference_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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_ShaferShenoyMRFInference_MRF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IMarkovRandomField< double > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_MRF" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  {
    try {
      result = (gum::IMarkovRandomField< double > *) &gum_ShaferShenoyMRFInference_Sl_double_Sg__MRF((gum::ShaferShenoyMRFInference< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IMarkovRandomFieldT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_posterior__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_posterior" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_posterior" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_ShaferShenoyMRFInference_Sl_double_Sg__posterior__SWIG_2(arg1,SWIG_STD_MOVE(arg2));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_posterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_posterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyMRFInference_posterior__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_posterior__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_posterior__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyMRFInference_posterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyMRFInference< double >::posterior(gum::NodeId const)\n"
    "    gum::ShaferShenoyMRFInference< double >::posterior(std::string const &)\n"
    "    gum::ShaferShenoyMRFInference< double >::posterior(std::string const)\n");
  return 0;
}


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


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


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_nbrJointTargets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_nbrJointTargets" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  {
    try {
      result = gum_ShaferShenoyMRFInference_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_ShaferShenoyMRFInference_evidenceJointImpact__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 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 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_evidenceJointImpact" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_evidenceJointImpact" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_evidenceJointImpact" "', 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 '" "ShaferShenoyMRFInference_evidenceJointImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_evidenceJointImpact" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = gum_ShaferShenoyMRFInference_Sl_double_Sg__evidenceJointImpact__SWIG_0(arg1,(gum::Set< std::size_t > const &)*arg2,(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_evidenceJointImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 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::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_evidenceJointImpact" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< 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 '" "ShaferShenoyMRFInference_evidenceJointImpact" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_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 '" "ShaferShenoyMRFInference_evidenceJointImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ShaferShenoyMRFInference_evidenceJointImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_ShaferShenoyMRFInference_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::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_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_ShaferShenoyMRFInference_setEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_setEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_updateEvidence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_updateEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_updateEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__updateEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_setTargets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_setTargets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_setTargets" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__setTargets(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_hardEvidenceNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_hardEvidenceNodes" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ShaferShenoyMRFInference_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_softEvidenceNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_softEvidenceNodes" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ShaferShenoyMRFInference_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_targets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_targets" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ShaferShenoyMRFInference_Sl_double_Sg__targets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_evidenceImpact__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_evidenceImpact" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_ShaferShenoyMRFInference_Sl_double_Sg__evidenceImpact__SWIG_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_evidenceImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_evidenceImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      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) goto check_1;
    return _wrap_ShaferShenoyMRFInference_evidenceImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_ShaferShenoyMRFInference_evidenceImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_evidenceImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyMRFInference_evidenceImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyMRFInference< double >::evidenceImpact(gum::NodeId,gum::NodeSet const &)\n"
    "    gum::ShaferShenoyMRFInference< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::ShaferShenoyMRFInference< double >::evidenceImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_jointMutualInformation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_jointMutualInformation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_jointMutualInformation" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (double)gum_ShaferShenoyMRFInference_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_ShaferShenoyMRFInference_evidenceJointImpact__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_evidenceJointImpact" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_ShaferShenoyMRFInference_Sl_double_Sg__evidenceJointImpact__SWIG_2(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_evidenceJointImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_evidenceJointImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      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) goto check_1;
    {
      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) goto check_1;
    return _wrap_ShaferShenoyMRFInference_evidenceJointImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_ShaferShenoyMRFInference_evidenceJointImpact__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_ShaferShenoyMRFInference_evidenceJointImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyMRFInference_evidenceJointImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyMRFInference< double >::evidenceJointImpact(gum::NodeSet const &,gum::NodeSet const &)\n"
    "    gum::ShaferShenoyMRFInference< double >::evidenceJointImpact(std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::ShaferShenoyMRFInference< double >::evidenceJointImpact(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_jointPosterior(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Tensor< double > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_jointPosterior", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_jointPosterior" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_ShaferShenoyMRFInference_Sl_double_Sg__jointPosterior(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_addJointTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_addJointTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_addJointTarget" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__addJointTarget(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_eraseJointTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_eraseJointTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_eraseJointTarget" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ShaferShenoyMRFInference_Sl_double_Sg__eraseJointTarget(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyMRFInference_isJointTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyMRFInference_isJointTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_isJointTarget" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (bool)gum_ShaferShenoyMRFInference_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_ShaferShenoyMRFInference_jointTargets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyMRFInference< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyMRFInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyMRFInference_jointTargets" "', argument " "1"" of type '" "gum::ShaferShenoyMRFInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyMRFInference< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ShaferShenoyMRFInference_Sl_double_Sg__jointTargets((gum::ShaferShenoyMRFInference< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


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

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

static PyMethodDef SwigMethods[] = {
	 { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, NULL},
	 { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, NULL},
	 { "SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
	 { "SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
	 { "SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
	 { "SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
	 { "SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_O, NULL},
	 { "SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_O, NULL},
	 { "SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_O, NULL},
	 { "SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_O, NULL},
	 { "SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
	 { "SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
	 { "SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
	 { "SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
	 { "SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
	 { "SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
	 { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
	 { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
	 { "JunctionTreeGenerator_junctionTree", _wrap_JunctionTreeGenerator_junctionTree, METH_VARARGS, "\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"
		"\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"
		"\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"
		"\n"
		"JunctionTreeGenerator is use to generate junction tree or binary junction tree from Bayesian networks.\n"
		"\n"
		"JunctionTreeGenerator() -> JunctionTreeGenerator\n"
		"    default constructor\n"
		"\n"
		""},
	 { "delete_JunctionTreeGenerator", _wrap_delete_JunctionTreeGenerator, METH_O, NULL},
	 { "JunctionTreeGenerator_swigregister", JunctionTreeGenerator_swigregister, METH_O, NULL},
	 { "JunctionTreeGenerator_swiginit", JunctionTreeGenerator_swiginit, METH_VARARGS, NULL},
	 { "Vector_iterator", _wrap_Vector_iterator, METH_O, NULL},
	 { "Vector___nonzero__", _wrap_Vector___nonzero__, METH_O, NULL},
	 { "Vector___bool__", _wrap_Vector___bool__, METH_O, NULL},
	 { "Vector___len__", _wrap_Vector___len__, METH_O, NULL},
	 { "Vector___getslice__", _wrap_Vector___getslice__, METH_VARARGS, NULL},
	 { "Vector___setslice__", _wrap_Vector___setslice__, METH_VARARGS, NULL},
	 { "Vector___delslice__", _wrap_Vector___delslice__, METH_VARARGS, NULL},
	 { "Vector___delitem__", _wrap_Vector___delitem__, METH_VARARGS, NULL},
	 { "Vector___getitem__", _wrap_Vector___getitem__, METH_VARARGS, NULL},
	 { "Vector___setitem__", _wrap_Vector___setitem__, METH_VARARGS, NULL},
	 { "Vector_pop", _wrap_Vector_pop, METH_O, NULL},
	 { "Vector_append", _wrap_Vector_append, METH_VARARGS, NULL},
	 { "Vector_empty", _wrap_Vector_empty, METH_O, NULL},
	 { "Vector_size", _wrap_Vector_size, METH_O, NULL},
	 { "Vector_swap", _wrap_Vector_swap, METH_VARARGS, NULL},
	 { "Vector_begin", _wrap_Vector_begin, METH_O, NULL},
	 { "Vector_end", _wrap_Vector_end, METH_O, NULL},
	 { "Vector_rbegin", _wrap_Vector_rbegin, METH_O, NULL},
	 { "Vector_rend", _wrap_Vector_rend, METH_O, NULL},
	 { "Vector_clear", _wrap_Vector_clear, METH_O, NULL},
	 { "Vector_get_allocator", _wrap_Vector_get_allocator, METH_O, NULL},
	 { "Vector_pop_back", _wrap_Vector_pop_back, METH_O, NULL},
	 { "Vector_erase", _wrap_Vector_erase, METH_VARARGS, NULL},
	 { "new_Vector", _wrap_new_Vector, METH_VARARGS, NULL},
	 { "Vector_push_back", _wrap_Vector_push_back, METH_VARARGS, NULL},
	 { "Vector_front", _wrap_Vector_front, METH_O, NULL},
	 { "Vector_back", _wrap_Vector_back, METH_O, NULL},
	 { "Vector_assign", _wrap_Vector_assign, METH_VARARGS, NULL},
	 { "Vector_resize", _wrap_Vector_resize, METH_VARARGS, NULL},
	 { "Vector_insert", _wrap_Vector_insert, METH_VARARGS, NULL},
	 { "Vector_reserve", _wrap_Vector_reserve, METH_VARARGS, NULL},
	 { "Vector_capacity", _wrap_Vector_capacity, METH_O, NULL},
	 { "delete_Vector", _wrap_delete_Vector, METH_O, NULL},
	 { "Vector_swigregister", Vector_swigregister, METH_O, NULL},
	 { "Vector_swiginit", Vector_swiginit, METH_VARARGS, NULL},
	 { "Vector_uint_iterator", _wrap_Vector_uint_iterator, METH_O, NULL},
	 { "Vector_uint___nonzero__", _wrap_Vector_uint___nonzero__, METH_O, NULL},
	 { "Vector_uint___bool__", _wrap_Vector_uint___bool__, METH_O, NULL},
	 { "Vector_uint___len__", _wrap_Vector_uint___len__, METH_O, NULL},
	 { "Vector_uint___getslice__", _wrap_Vector_uint___getslice__, METH_VARARGS, NULL},
	 { "Vector_uint___setslice__", _wrap_Vector_uint___setslice__, METH_VARARGS, NULL},
	 { "Vector_uint___delslice__", _wrap_Vector_uint___delslice__, METH_VARARGS, NULL},
	 { "Vector_uint___delitem__", _wrap_Vector_uint___delitem__, METH_VARARGS, NULL},
	 { "Vector_uint___getitem__", _wrap_Vector_uint___getitem__, METH_VARARGS, NULL},
	 { "Vector_uint___setitem__", _wrap_Vector_uint___setitem__, METH_VARARGS, NULL},
	 { "Vector_uint_pop", _wrap_Vector_uint_pop, METH_O, NULL},
	 { "Vector_uint_append", _wrap_Vector_uint_append, METH_VARARGS, NULL},
	 { "Vector_uint_empty", _wrap_Vector_uint_empty, METH_O, NULL},
	 { "Vector_uint_size", _wrap_Vector_uint_size, METH_O, NULL},
	 { "Vector_uint_swap", _wrap_Vector_uint_swap, METH_VARARGS, NULL},
	 { "Vector_uint_begin", _wrap_Vector_uint_begin, METH_O, NULL},
	 { "Vector_uint_end", _wrap_Vector_uint_end, METH_O, NULL},
	 { "Vector_uint_rbegin", _wrap_Vector_uint_rbegin, METH_O, NULL},
	 { "Vector_uint_rend", _wrap_Vector_uint_rend, METH_O, NULL},
	 { "Vector_uint_clear", _wrap_Vector_uint_clear, METH_O, NULL},
	 { "Vector_uint_get_allocator", _wrap_Vector_uint_get_allocator, METH_O, NULL},
	 { "Vector_uint_pop_back", _wrap_Vector_uint_pop_back, METH_O, NULL},
	 { "Vector_uint_erase", _wrap_Vector_uint_erase, METH_VARARGS, NULL},
	 { "new_Vector_uint", _wrap_new_Vector_uint, METH_VARARGS, NULL},
	 { "Vector_uint_push_back", _wrap_Vector_uint_push_back, METH_VARARGS, NULL},
	 { "Vector_uint_front", _wrap_Vector_uint_front, METH_O, NULL},
	 { "Vector_uint_back", _wrap_Vector_uint_back, METH_O, NULL},
	 { "Vector_uint_assign", _wrap_Vector_uint_assign, METH_VARARGS, NULL},
	 { "Vector_uint_resize", _wrap_Vector_uint_resize, METH_VARARGS, NULL},
	 { "Vector_uint_insert", _wrap_Vector_uint_insert, METH_VARARGS, NULL},
	 { "Vector_uint_reserve", _wrap_Vector_uint_reserve, METH_VARARGS, NULL},
	 { "Vector_uint_capacity", _wrap_Vector_uint_capacity, METH_O, NULL},
	 { "delete_Vector_uint", _wrap_delete_Vector_uint, METH_O, NULL},
	 { "Vector_uint_swigregister", Vector_uint_swigregister, METH_O, NULL},
	 { "Vector_uint_swiginit", Vector_uint_swiginit, METH_VARARGS, NULL},
	 { "Vector_int_iterator", _wrap_Vector_int_iterator, METH_O, NULL},
	 { "Vector_int___nonzero__", _wrap_Vector_int___nonzero__, METH_O, NULL},
	 { "Vector_int___bool__", _wrap_Vector_int___bool__, METH_O, NULL},
	 { "Vector_int___len__", _wrap_Vector_int___len__, METH_O, NULL},
	 { "Vector_int___getslice__", _wrap_Vector_int___getslice__, METH_VARARGS, NULL},
	 { "Vector_int___setslice__", _wrap_Vector_int___setslice__, METH_VARARGS, NULL},
	 { "Vector_int___delslice__", _wrap_Vector_int___delslice__, METH_VARARGS, NULL},
	 { "Vector_int___delitem__", _wrap_Vector_int___delitem__, METH_VARARGS, NULL},
	 { "Vector_int___getitem__", _wrap_Vector_int___getitem__, METH_VARARGS, NULL},
	 { "Vector_int___setitem__", _wrap_Vector_int___setitem__, METH_VARARGS, NULL},
	 { "Vector_int_pop", _wrap_Vector_int_pop, METH_O, NULL},
	 { "Vector_int_append", _wrap_Vector_int_append, METH_VARARGS, NULL},
	 { "Vector_int_empty", _wrap_Vector_int_empty, METH_O, NULL},
	 { "Vector_int_size", _wrap_Vector_int_size, METH_O, NULL},
	 { "Vector_int_swap", _wrap_Vector_int_swap, METH_VARARGS, NULL},
	 { "Vector_int_begin", _wrap_Vector_int_begin, METH_O, NULL},
	 { "Vector_int_end", _wrap_Vector_int_end, METH_O, NULL},
	 { "Vector_int_rbegin", _wrap_Vector_int_rbegin, METH_O, NULL},
	 { "Vector_int_rend", _wrap_Vector_int_rend, METH_O, NULL},
	 { "Vector_int_clear", _wrap_Vector_int_clear, METH_O, NULL},
	 { "Vector_int_get_allocator", _wrap_Vector_int_get_allocator, METH_O, NULL},
	 { "Vector_int_pop_back", _wrap_Vector_int_pop_back, METH_O, NULL},
	 { "Vector_int_erase", _wrap_Vector_int_erase, METH_VARARGS, NULL},
	 { "new_Vector_int", _wrap_new_Vector_int, METH_VARARGS, NULL},
	 { "Vector_int_push_back", _wrap_Vector_int_push_back, METH_VARARGS, NULL},
	 { "Vector_int_front", _wrap_Vector_int_front, METH_O, NULL},
	 { "Vector_int_back", _wrap_Vector_int_back, METH_O, NULL},
	 { "Vector_int_assign", _wrap_Vector_int_assign, METH_VARARGS, NULL},
	 { "Vector_int_resize", _wrap_Vector_int_resize, METH_VARARGS, NULL},
	 { "Vector_int_insert", _wrap_Vector_int_insert, METH_VARARGS, NULL},
	 { "Vector_int_reserve", _wrap_Vector_int_reserve, METH_VARARGS, NULL},
	 { "Vector_int_capacity", _wrap_Vector_int_capacity, METH_O, NULL},
	 { "delete_Vector_int", _wrap_delete_Vector_int, METH_O, NULL},
	 { "Vector_int_swigregister", Vector_int_swigregister, METH_O, NULL},
	 { "Vector_int_swiginit", Vector_int_swiginit, METH_VARARGS, NULL},
	 { "Vector_string_iterator", _wrap_Vector_string_iterator, METH_O, NULL},
	 { "Vector_string___nonzero__", _wrap_Vector_string___nonzero__, METH_O, NULL},
	 { "Vector_string___bool__", _wrap_Vector_string___bool__, METH_O, NULL},
	 { "Vector_string___len__", _wrap_Vector_string___len__, METH_O, NULL},
	 { "Vector_string___getslice__", _wrap_Vector_string___getslice__, METH_VARARGS, NULL},
	 { "Vector_string___setslice__", _wrap_Vector_string___setslice__, METH_VARARGS, NULL},
	 { "Vector_string___delslice__", _wrap_Vector_string___delslice__, METH_VARARGS, NULL},
	 { "Vector_string___delitem__", _wrap_Vector_string___delitem__, METH_VARARGS, NULL},
	 { "Vector_string___getitem__", _wrap_Vector_string___getitem__, METH_VARARGS, NULL},
	 { "Vector_string___setitem__", _wrap_Vector_string___setitem__, METH_VARARGS, NULL},
	 { "Vector_string_pop", _wrap_Vector_string_pop, METH_O, NULL},
	 { "Vector_string_append", _wrap_Vector_string_append, METH_VARARGS, NULL},
	 { "Vector_string_empty", _wrap_Vector_string_empty, METH_O, NULL},
	 { "Vector_string_size", _wrap_Vector_string_size, METH_O, NULL},
	 { "Vector_string_swap", _wrap_Vector_string_swap, METH_VARARGS, NULL},
	 { "Vector_string_begin", _wrap_Vector_string_begin, METH_O, NULL},
	 { "Vector_string_end", _wrap_Vector_string_end, METH_O, NULL},
	 { "Vector_string_rbegin", _wrap_Vector_string_rbegin, METH_O, NULL},
	 { "Vector_string_rend", _wrap_Vector_string_rend, METH_O, NULL},
	 { "Vector_string_clear", _wrap_Vector_string_clear, METH_O, NULL},
	 { "Vector_string_get_allocator", _wrap_Vector_string_get_allocator, METH_O, NULL},
	 { "Vector_string_pop_back", _wrap_Vector_string_pop_back, METH_O, NULL},
	 { "Vector_string_erase", _wrap_Vector_string_erase, METH_VARARGS, NULL},
	 { "new_Vector_string", _wrap_new_Vector_string, METH_VARARGS, NULL},
	 { "Vector_string_push_back", _wrap_Vector_string_push_back, METH_VARARGS, NULL},
	 { "Vector_string_front", _wrap_Vector_string_front, METH_O, NULL},
	 { "Vector_string_back", _wrap_Vector_string_back, METH_O, NULL},
	 { "Vector_string_assign", _wrap_Vector_string_assign, METH_VARARGS, NULL},
	 { "Vector_string_resize", _wrap_Vector_string_resize, METH_VARARGS, NULL},
	 { "Vector_string_insert", _wrap_Vector_string_insert, METH_VARARGS, NULL},
	 { "Vector_string_reserve", _wrap_Vector_string_reserve, METH_VARARGS, NULL},
	 { "Vector_string_capacity", _wrap_Vector_string_capacity, METH_O, NULL},
	 { "delete_Vector_string", _wrap_delete_Vector_string, METH_O, NULL},
	 { "Vector_string_swigregister", Vector_string_swigregister, METH_O, NULL},
	 { "Vector_string_swiginit", Vector_string_swiginit, METH_VARARGS, NULL},
	 { "new_GumException", _wrap_new_GumException, METH_VARARGS, NULL},
	 { "delete_GumException", _wrap_delete_GumException, METH_O, NULL},
	 { "GumException_what", _wrap_GumException_what, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the error message\n"
		"\n"
		""},
	 { "GumException_errorContent", _wrap_GumException_errorContent, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the error content\n"
		"\n"
		""},
	 { "GumException_errorType", _wrap_GumException_errorType, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the error type\n"
		"\n"
		""},
	 { "GumException_errorCallStack", _wrap_GumException_errorCallStack, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the error call stack\n"
		"\n"
		""},
	 { "GumException_swigregister", GumException_swigregister, METH_O, NULL},
	 { "GumException_swiginit", GumException_swiginit, METH_VARARGS, NULL},
	 { "_createMsg_", _wrap__createMsg_, METH_VARARGS, NULL},
	 { "new_FatalError", _wrap_new_FatalError, METH_VARARGS, NULL},
	 { "delete_FatalError", _wrap_delete_FatalError, METH_O, NULL},
	 { "FatalError_swigregister", FatalError_swigregister, METH_O, NULL},
	 { "FatalError_swiginit", FatalError_swiginit, METH_VARARGS, NULL},
	 { "new_NotImplementedYet", _wrap_new_NotImplementedYet, METH_VARARGS, NULL},
	 { "delete_NotImplementedYet", _wrap_delete_NotImplementedYet, METH_O, NULL},
	 { "NotImplementedYet_swigregister", NotImplementedYet_swigregister, METH_O, NULL},
	 { "NotImplementedYet_swiginit", NotImplementedYet_swiginit, METH_VARARGS, NULL},
	 { "new_IteratorError", _wrap_new_IteratorError, METH_VARARGS, NULL},
	 { "delete_IteratorError", _wrap_delete_IteratorError, METH_O, NULL},
	 { "IteratorError_swigregister", IteratorError_swigregister, METH_O, NULL},
	 { "IteratorError_swiginit", IteratorError_swiginit, METH_VARARGS, NULL},
	 { "new_UndefinedIteratorValue", _wrap_new_UndefinedIteratorValue, METH_VARARGS, NULL},
	 { "delete_UndefinedIteratorValue", _wrap_delete_UndefinedIteratorValue, METH_O, NULL},
	 { "UndefinedIteratorValue_swigregister", UndefinedIteratorValue_swigregister, METH_O, NULL},
	 { "UndefinedIteratorValue_swiginit", UndefinedIteratorValue_swiginit, METH_VARARGS, NULL},
	 { "new_UndefinedIteratorKey", _wrap_new_UndefinedIteratorKey, METH_VARARGS, NULL},
	 { "delete_UndefinedIteratorKey", _wrap_delete_UndefinedIteratorKey, METH_O, NULL},
	 { "UndefinedIteratorKey_swigregister", UndefinedIteratorKey_swigregister, METH_O, NULL},
	 { "UndefinedIteratorKey_swiginit", UndefinedIteratorKey_swiginit, METH_VARARGS, NULL},
	 { "new_NullElement", _wrap_new_NullElement, METH_VARARGS, NULL},
	 { "delete_NullElement", _wrap_delete_NullElement, METH_O, NULL},
	 { "NullElement_swigregister", NullElement_swigregister, METH_O, NULL},
	 { "NullElement_swiginit", NullElement_swiginit, METH_VARARGS, NULL},
	 { "new_UndefinedElement", _wrap_new_UndefinedElement, METH_VARARGS, NULL},
	 { "delete_UndefinedElement", _wrap_delete_UndefinedElement, METH_O, NULL},
	 { "UndefinedElement_swigregister", UndefinedElement_swigregister, METH_O, NULL},
	 { "UndefinedElement_swiginit", UndefinedElement_swiginit, METH_VARARGS, NULL},
	 { "new_SizeError", _wrap_new_SizeError, METH_VARARGS, NULL},
	 { "delete_SizeError", _wrap_delete_SizeError, METH_O, NULL},
	 { "SizeError_swigregister", SizeError_swigregister, METH_O, NULL},
	 { "SizeError_swiginit", SizeError_swiginit, METH_VARARGS, NULL},
	 { "new_ArgumentError", _wrap_new_ArgumentError, METH_VARARGS, NULL},
	 { "delete_ArgumentError", _wrap_delete_ArgumentError, METH_O, NULL},
	 { "ArgumentError_swigregister", ArgumentError_swigregister, METH_O, NULL},
	 { "ArgumentError_swiginit", ArgumentError_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidArgumentsNumber", _wrap_new_InvalidArgumentsNumber, METH_VARARGS, NULL},
	 { "delete_InvalidArgumentsNumber", _wrap_delete_InvalidArgumentsNumber, METH_O, NULL},
	 { "InvalidArgumentsNumber_swigregister", InvalidArgumentsNumber_swigregister, METH_O, NULL},
	 { "InvalidArgumentsNumber_swiginit", InvalidArgumentsNumber_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidArgument", _wrap_new_InvalidArgument, METH_VARARGS, NULL},
	 { "delete_InvalidArgument", _wrap_delete_InvalidArgument, METH_O, NULL},
	 { "InvalidArgument_swigregister", InvalidArgument_swigregister, METH_O, NULL},
	 { "InvalidArgument_swiginit", InvalidArgument_swiginit, METH_VARARGS, NULL},
	 { "new_IOError", _wrap_new_IOError, METH_VARARGS, NULL},
	 { "delete_IOError", _wrap_delete_IOError, METH_O, NULL},
	 { "IOError_swigregister", IOError_swigregister, METH_O, NULL},
	 { "IOError_swiginit", IOError_swiginit, METH_VARARGS, NULL},
	 { "new_FormatNotFound", _wrap_new_FormatNotFound, METH_VARARGS, NULL},
	 { "delete_FormatNotFound", _wrap_delete_FormatNotFound, METH_O, NULL},
	 { "FormatNotFound_swigregister", FormatNotFound_swigregister, METH_O, NULL},
	 { "FormatNotFound_swiginit", FormatNotFound_swiginit, METH_VARARGS, NULL},
	 { "new_OperationNotAllowed", _wrap_new_OperationNotAllowed, METH_VARARGS, NULL},
	 { "delete_OperationNotAllowed", _wrap_delete_OperationNotAllowed, METH_O, NULL},
	 { "OperationNotAllowed_swigregister", OperationNotAllowed_swigregister, METH_O, NULL},
	 { "OperationNotAllowed_swiginit", OperationNotAllowed_swiginit, METH_VARARGS, NULL},
	 { "new_NotFound", _wrap_new_NotFound, METH_VARARGS, NULL},
	 { "delete_NotFound", _wrap_delete_NotFound, METH_O, NULL},
	 { "NotFound_swigregister", NotFound_swigregister, METH_O, NULL},
	 { "NotFound_swiginit", NotFound_swiginit, METH_VARARGS, NULL},
	 { "new_OutOfBounds", _wrap_new_OutOfBounds, METH_VARARGS, NULL},
	 { "delete_OutOfBounds", _wrap_delete_OutOfBounds, METH_O, NULL},
	 { "OutOfBounds_swigregister", OutOfBounds_swigregister, METH_O, NULL},
	 { "OutOfBounds_swiginit", OutOfBounds_swiginit, METH_VARARGS, NULL},
	 { "new_DuplicateElement", _wrap_new_DuplicateElement, METH_VARARGS, NULL},
	 { "delete_DuplicateElement", _wrap_delete_DuplicateElement, METH_O, NULL},
	 { "DuplicateElement_swigregister", DuplicateElement_swigregister, METH_O, NULL},
	 { "DuplicateElement_swiginit", DuplicateElement_swiginit, METH_VARARGS, NULL},
	 { "new_DuplicateLabel", _wrap_new_DuplicateLabel, METH_VARARGS, NULL},
	 { "delete_DuplicateLabel", _wrap_delete_DuplicateLabel, METH_O, NULL},
	 { "DuplicateLabel_swigregister", DuplicateLabel_swigregister, METH_O, NULL},
	 { "DuplicateLabel_swiginit", DuplicateLabel_swiginit, METH_VARARGS, NULL},
	 { "new_GraphError", _wrap_new_GraphError, METH_VARARGS, NULL},
	 { "delete_GraphError", _wrap_delete_GraphError, METH_O, NULL},
	 { "GraphError_swigregister", GraphError_swigregister, METH_O, NULL},
	 { "GraphError_swiginit", GraphError_swiginit, METH_VARARGS, NULL},
	 { "new_NoNeighbour", _wrap_new_NoNeighbour, METH_VARARGS, NULL},
	 { "delete_NoNeighbour", _wrap_delete_NoNeighbour, METH_O, NULL},
	 { "NoNeighbour_swigregister", NoNeighbour_swigregister, METH_O, NULL},
	 { "NoNeighbour_swiginit", NoNeighbour_swiginit, METH_VARARGS, NULL},
	 { "new_NoParent", _wrap_new_NoParent, METH_VARARGS, NULL},
	 { "delete_NoParent", _wrap_delete_NoParent, METH_O, NULL},
	 { "NoParent_swigregister", NoParent_swigregister, METH_O, NULL},
	 { "NoParent_swiginit", NoParent_swiginit, METH_VARARGS, NULL},
	 { "new_NoChild", _wrap_new_NoChild, METH_VARARGS, NULL},
	 { "delete_NoChild", _wrap_delete_NoChild, METH_O, NULL},
	 { "NoChild_swigregister", NoChild_swigregister, METH_O, NULL},
	 { "NoChild_swiginit", NoChild_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidEdge", _wrap_new_InvalidEdge, METH_VARARGS, NULL},
	 { "delete_InvalidEdge", _wrap_delete_InvalidEdge, METH_O, NULL},
	 { "InvalidEdge_swigregister", InvalidEdge_swigregister, METH_O, NULL},
	 { "InvalidEdge_swiginit", InvalidEdge_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidArc", _wrap_new_InvalidArc, METH_VARARGS, NULL},
	 { "delete_InvalidArc", _wrap_delete_InvalidArc, METH_O, NULL},
	 { "InvalidArc_swigregister", InvalidArc_swigregister, METH_O, NULL},
	 { "InvalidArc_swiginit", InvalidArc_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidNode", _wrap_new_InvalidNode, METH_VARARGS, NULL},
	 { "delete_InvalidNode", _wrap_delete_InvalidNode, METH_O, NULL},
	 { "InvalidNode_swigregister", InvalidNode_swigregister, METH_O, NULL},
	 { "InvalidNode_swiginit", InvalidNode_swiginit, METH_VARARGS, NULL},
	 { "new_DefaultInLabel", _wrap_new_DefaultInLabel, METH_VARARGS, NULL},
	 { "delete_DefaultInLabel", _wrap_delete_DefaultInLabel, METH_O, NULL},
	 { "DefaultInLabel_swigregister", DefaultInLabel_swigregister, METH_O, NULL},
	 { "DefaultInLabel_swiginit", DefaultInLabel_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidDirectedCycle", _wrap_new_InvalidDirectedCycle, METH_VARARGS, NULL},
	 { "delete_InvalidDirectedCycle", _wrap_delete_InvalidDirectedCycle, METH_O, NULL},
	 { "InvalidDirectedCycle_swigregister", InvalidDirectedCycle_swigregister, METH_O, NULL},
	 { "InvalidDirectedCycle_swiginit", InvalidDirectedCycle_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidPartiallyDirectedCycle", _wrap_new_InvalidPartiallyDirectedCycle, METH_VARARGS, NULL},
	 { "delete_InvalidPartiallyDirectedCycle", _wrap_delete_InvalidPartiallyDirectedCycle, METH_O, NULL},
	 { "InvalidPartiallyDirectedCycle_swigregister", InvalidPartiallyDirectedCycle_swigregister, METH_O, NULL},
	 { "InvalidPartiallyDirectedCycle_swiginit", InvalidPartiallyDirectedCycle_swiginit, METH_VARARGS, NULL},
	 { "new_CPTError", _wrap_new_CPTError, METH_VARARGS, NULL},
	 { "delete_CPTError", _wrap_delete_CPTError, METH_O, NULL},
	 { "CPTError_swigregister", CPTError_swigregister, METH_O, NULL},
	 { "CPTError_swiginit", CPTError_swiginit, METH_VARARGS, NULL},
	 { "new_ScheduleMultiDimError", _wrap_new_ScheduleMultiDimError, METH_VARARGS, NULL},
	 { "delete_ScheduleMultiDimError", _wrap_delete_ScheduleMultiDimError, METH_O, NULL},
	 { "ScheduleMultiDimError_swigregister", ScheduleMultiDimError_swigregister, METH_O, NULL},
	 { "ScheduleMultiDimError_swiginit", ScheduleMultiDimError_swiginit, METH_VARARGS, NULL},
	 { "new_AbstractScheduleMultiDim", _wrap_new_AbstractScheduleMultiDim, METH_VARARGS, NULL},
	 { "delete_AbstractScheduleMultiDim", _wrap_delete_AbstractScheduleMultiDim, METH_O, NULL},
	 { "AbstractScheduleMultiDim_swigregister", AbstractScheduleMultiDim_swigregister, METH_O, NULL},
	 { "AbstractScheduleMultiDim_swiginit", AbstractScheduleMultiDim_swiginit, METH_VARARGS, NULL},
	 { "new_UnknownScheduleMultiDim", _wrap_new_UnknownScheduleMultiDim, METH_VARARGS, NULL},
	 { "delete_UnknownScheduleMultiDim", _wrap_delete_UnknownScheduleMultiDim, METH_O, NULL},
	 { "UnknownScheduleMultiDim_swigregister", UnknownScheduleMultiDim_swigregister, METH_O, NULL},
	 { "UnknownScheduleMultiDim_swiginit", UnknownScheduleMultiDim_swiginit, METH_VARARGS, NULL},
	 { "new_DuplicateScheduleMultiDim", _wrap_new_DuplicateScheduleMultiDim, METH_VARARGS, NULL},
	 { "delete_DuplicateScheduleMultiDim", _wrap_delete_DuplicateScheduleMultiDim, METH_O, NULL},
	 { "DuplicateScheduleMultiDim_swigregister", DuplicateScheduleMultiDim_swigregister, METH_O, NULL},
	 { "DuplicateScheduleMultiDim_swiginit", DuplicateScheduleMultiDim_swiginit, METH_VARARGS, NULL},
	 { "new_ScheduleOperationError", _wrap_new_ScheduleOperationError, METH_VARARGS, NULL},
	 { "delete_ScheduleOperationError", _wrap_delete_ScheduleOperationError, METH_O, NULL},
	 { "ScheduleOperationError_swigregister", ScheduleOperationError_swigregister, METH_O, NULL},
	 { "ScheduleOperationError_swiginit", ScheduleOperationError_swiginit, METH_VARARGS, NULL},
	 { "new_UnknownScheduleOperation", _wrap_new_UnknownScheduleOperation, METH_VARARGS, NULL},
	 { "delete_UnknownScheduleOperation", _wrap_delete_UnknownScheduleOperation, METH_O, NULL},
	 { "UnknownScheduleOperation_swigregister", UnknownScheduleOperation_swigregister, METH_O, NULL},
	 { "UnknownScheduleOperation_swiginit", UnknownScheduleOperation_swiginit, METH_VARARGS, NULL},
	 { "new_UnavailableScheduleOperation", _wrap_new_UnavailableScheduleOperation, METH_VARARGS, NULL},
	 { "delete_UnavailableScheduleOperation", _wrap_delete_UnavailableScheduleOperation, METH_O, NULL},
	 { "UnavailableScheduleOperation_swigregister", UnavailableScheduleOperation_swigregister, METH_O, NULL},
	 { "UnavailableScheduleOperation_swiginit", UnavailableScheduleOperation_swiginit, METH_VARARGS, NULL},
	 { "new_UnexecutedScheduleOperation", _wrap_new_UnexecutedScheduleOperation, METH_VARARGS, NULL},
	 { "delete_UnexecutedScheduleOperation", _wrap_delete_UnexecutedScheduleOperation, METH_O, NULL},
	 { "UnexecutedScheduleOperation_swigregister", UnexecutedScheduleOperation_swigregister, METH_O, NULL},
	 { "UnexecutedScheduleOperation_swiginit", UnexecutedScheduleOperation_swiginit, METH_VARARGS, NULL},
	 { "new_IncompatibleEvidence", _wrap_new_IncompatibleEvidence, METH_VARARGS, NULL},
	 { "delete_IncompatibleEvidence", _wrap_delete_IncompatibleEvidence, METH_O, NULL},
	 { "IncompatibleEvidence_swigregister", IncompatibleEvidence_swigregister, METH_O, NULL},
	 { "IncompatibleEvidence_swiginit", IncompatibleEvidence_swiginit, METH_VARARGS, NULL},
	 { "new_FactoryError", _wrap_new_FactoryError, METH_VARARGS, NULL},
	 { "delete_FactoryError", _wrap_delete_FactoryError, METH_O, NULL},
	 { "FactoryError_swigregister", FactoryError_swigregister, METH_O, NULL},
	 { "FactoryError_swiginit", FactoryError_swiginit, METH_VARARGS, NULL},
	 { "new_FactoryInvalidState", _wrap_new_FactoryInvalidState, METH_VARARGS, NULL},
	 { "delete_FactoryInvalidState", _wrap_delete_FactoryInvalidState, METH_O, NULL},
	 { "FactoryInvalidState_swigregister", FactoryInvalidState_swigregister, METH_O, NULL},
	 { "FactoryInvalidState_swiginit", FactoryInvalidState_swiginit, METH_VARARGS, NULL},
	 { "new_TypeError", _wrap_new_TypeError, METH_VARARGS, NULL},
	 { "delete_TypeError", _wrap_delete_TypeError, METH_O, NULL},
	 { "TypeError_swigregister", TypeError_swigregister, METH_O, NULL},
	 { "TypeError_swiginit", TypeError_swiginit, METH_VARARGS, NULL},
	 { "new_WrongClassElement", _wrap_new_WrongClassElement, METH_VARARGS, NULL},
	 { "delete_WrongClassElement", _wrap_delete_WrongClassElement, METH_O, NULL},
	 { "WrongClassElement_swigregister", WrongClassElement_swigregister, METH_O, NULL},
	 { "WrongClassElement_swiginit", WrongClassElement_swiginit, METH_VARARGS, NULL},
	 { "new_PRMTypeError", _wrap_new_PRMTypeError, METH_VARARGS, NULL},
	 { "delete_PRMTypeError", _wrap_delete_PRMTypeError, METH_O, NULL},
	 { "PRMTypeError_swigregister", PRMTypeError_swigregister, METH_O, NULL},
	 { "PRMTypeError_swiginit", PRMTypeError_swiginit, METH_VARARGS, NULL},
	 { "new_LearningError", _wrap_new_LearningError, METH_VARARGS, NULL},
	 { "delete_LearningError", _wrap_delete_LearningError, METH_O, NULL},
	 { "LearningError_swigregister", LearningError_swigregister, METH_O, NULL},
	 { "LearningError_swiginit", LearningError_swiginit, METH_VARARGS, NULL},
	 { "new_IncompatibleScorePrior", _wrap_new_IncompatibleScorePrior, METH_VARARGS, NULL},
	 { "delete_IncompatibleScorePrior", _wrap_delete_IncompatibleScorePrior, METH_O, NULL},
	 { "IncompatibleScorePrior_swigregister", IncompatibleScorePrior_swigregister, METH_O, NULL},
	 { "IncompatibleScorePrior_swiginit", IncompatibleScorePrior_swiginit, METH_VARARGS, NULL},
	 { "new_PossiblyIncompatibleScorePrior", _wrap_new_PossiblyIncompatibleScorePrior, METH_VARARGS, NULL},
	 { "delete_PossiblyIncompatibleScorePrior", _wrap_delete_PossiblyIncompatibleScorePrior, METH_O, NULL},
	 { "PossiblyIncompatibleScorePrior_swigregister", PossiblyIncompatibleScorePrior_swigregister, METH_O, NULL},
	 { "PossiblyIncompatibleScorePrior_swiginit", PossiblyIncompatibleScorePrior_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseError", _wrap_new_DatabaseError, METH_VARARGS, NULL},
	 { "delete_DatabaseError", _wrap_delete_DatabaseError, METH_O, NULL},
	 { "DatabaseError_swigregister", DatabaseError_swigregister, METH_O, NULL},
	 { "DatabaseError_swiginit", DatabaseError_swiginit, METH_VARARGS, NULL},
	 { "new_MissingVariableInDatabase", _wrap_new_MissingVariableInDatabase, METH_VARARGS, NULL},
	 { "delete_MissingVariableInDatabase", _wrap_delete_MissingVariableInDatabase, METH_O, NULL},
	 { "MissingVariableInDatabase_swigregister", MissingVariableInDatabase_swigregister, METH_O, NULL},
	 { "MissingVariableInDatabase_swiginit", MissingVariableInDatabase_swiginit, METH_VARARGS, NULL},
	 { "new_MissingValueInDatabase", _wrap_new_MissingValueInDatabase, METH_VARARGS, NULL},
	 { "delete_MissingValueInDatabase", _wrap_delete_MissingValueInDatabase, METH_O, NULL},
	 { "MissingValueInDatabase_swigregister", MissingValueInDatabase_swigregister, METH_O, NULL},
	 { "MissingValueInDatabase_swiginit", MissingValueInDatabase_swiginit, METH_VARARGS, NULL},
	 { "new_UnknownLabelInDatabase", _wrap_new_UnknownLabelInDatabase, METH_VARARGS, NULL},
	 { "delete_UnknownLabelInDatabase", _wrap_delete_UnknownLabelInDatabase, METH_O, NULL},
	 { "UnknownLabelInDatabase_swigregister", UnknownLabelInDatabase_swigregister, METH_O, NULL},
	 { "UnknownLabelInDatabase_swiginit", UnknownLabelInDatabase_swiginit, METH_VARARGS, NULL},
	 { "new_SyntaxError", _wrap_new_SyntaxError, METH_VARARGS, NULL},
	 { "SyntaxError_col", _wrap_SyntaxError_col, METH_O, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the indice of the line of the error\n"
		"\n"
		""},
	 { "SyntaxError_filename", _wrap_SyntaxError_filename, METH_O, NULL},
	 { "delete_SyntaxError", _wrap_delete_SyntaxError, METH_O, NULL},
	 { "SyntaxError_swigregister", SyntaxError_swigregister, METH_O, NULL},
	 { "SyntaxError_swiginit", SyntaxError_swiginit, METH_VARARGS, NULL},
	 { "setNumberOfThreads", _wrap_setNumberOfThreads, METH_O, "\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"
		""},
	 { "isOMP", _wrap_isOMP, METH_NOARGS, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if OMP has been set at compilation, False otherwise\n"
		"\n"
		""},
	 { "dispatchRangeToThreads", _wrap_dispatchRangeToThreads, METH_VARARGS, NULL},
	 { "generator", _wrap_generator, METH_NOARGS, NULL},
	 { "randomValue", _wrap_randomValue, METH_VARARGS, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  a value randomly drawn (0 or 1)\n"
		"\n"
		""},
	 { "randomProba", _wrap_randomProba, METH_NOARGS, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    a random number between 0 and 1 included (i.e. a proba).\n"
		"\n"
		""},
	 { "randomGeneratorSeed", _wrap_randomGeneratorSeed, METH_NOARGS, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  a randomly generated seed\n"
		"\n"
		""},
	 { "currentRandomGeneratorValue", _wrap_currentRandomGeneratorValue, METH_NOARGS, NULL},
	 { "initRandom", _wrap_initRandom, METH_VARARGS, "\n"
		"\n"
		"Initialize random generator seed. If `seed=0`, the generator is initialized from the current time in ms. `seed!=0` allows to fix the generator in a certain stage and then allows to repeat the same pseudo-random numbers sequence.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"seed : int\n"
		"  the seed used to initialize the random generator (0 if using time)\n"
		"\n"
		""},
	 { "randomGenerator", _wrap_randomGenerator, METH_NOARGS, NULL},
	 { "delete_Variable", _wrap_delete_Variable, METH_O, NULL},
	 { "Variable_clone", _wrap_Variable_clone, METH_O, "\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, NULL},
	 { "Variable_setName", _wrap_Variable_setName, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the name of the variable\n"
		"\n"
		""},
	 { "Variable_setDescription", _wrap_Variable_setDescription, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the description of the variable\n"
		"\n"
		""},
	 { "Variable_varType", _wrap_Variable_varType, METH_O, NULL},
	 { "Variable_domain", _wrap_Variable_domain, METH_O, NULL},
	 { "Variable_swigregister", Variable_swigregister, METH_O, NULL},
	 { "delete_DiscreteVariable", _wrap_delete_DiscreteVariable, METH_O, NULL},
	 { "DiscreteVariable_clone", _wrap_DiscreteVariable_clone, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  pyagrum.DiscreteVariable\n"
		"	a copy of the DiscreteVariable\n"
		"\n"
		""},
	 { "DiscreteVariable_empty", _wrap_DiscreteVariable_empty, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the domain size < 2\n"
		"\n"
		""},
	 { "DiscreteVariable_domainSize", _wrap_DiscreteVariable_domainSize, METH_O, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	a tuple containing the labels\n"
		"\n"
		""},
	 { "DiscreteVariable_numerical", _wrap_DiscreteVariable_numerical, METH_VARARGS, "\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_isEmpirical", _wrap_DiscreteVariable_isEmpirical, METH_O, NULL},
	 { "DiscreteVariable_closestIndex", _wrap_DiscreteVariable_closestIndex, METH_VARARGS, "\n"
		"\n"
		"For numerical discrete variables (all except :class:`gum.LabelizedVariable`), this method returns the index of the closest value to a given float value in the variable's domain.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value : float\n"
		"  the value for which we want to find the closest index\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the index of the closest value to `value` in the variable's domain\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotImplementedYet\n"
		"  if the variable is not numerical discrete (i.e., if it is a :class:`gum.LabelizedVariable`).\n"
		"\n"
		""},
	 { "DiscreteVariable_closestLabel", _wrap_DiscreteVariable_closestLabel, METH_VARARGS, "\n"
		"\n"
		"For numerical discrete variables (all except :class:`gum.LabelizedVariable`), this method returns the label of the closest value to a given float value in the variable's domain.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value : float\n"
		"  the value for which we want to find the closest index\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"  the label of the closest value to `value` in the variable's domain\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  if the variable is not numerical discrete (i.e., if it is a :class:`gum.LabelizedVariable`).\n"
		"\n"
		""},
	 { "DiscreteVariable_varType", _wrap_DiscreteVariable_varType, METH_O, "\n"
		"\n"
		"returns the type of variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	the type of the variable.\n"
		"\n"
		"	0: DiscretizedVariable, 1: LabelizedVariable, 2: IntegerVariable, 3: RangeVariable, 4:\n"
		"\n"
		""},
	 { "DiscreteVariable_toFast", _wrap_DiscreteVariable_toFast, METH_O, NULL},
	 { "DiscreteVariable_index", _wrap_DiscreteVariable_index, METH_VARARGS, "\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"
		"\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"
		"pyagrum.OutOfBounds\n"
		"	If the variable does not contain the label\n"
		"\n"
		""},
	 { "DiscreteVariable_toStringWithDescription", _wrap_DiscreteVariable_toStringWithDescription, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	a description of the variable\n"
		"\n"
		""},
	 { "DiscreteVariable_domain", _wrap_DiscreteVariable_domain, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the domain of the variable\n"
		"\n"
		""},
	 { "DiscreteVariable_stype", _wrap_DiscreteVariable_stype, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	a description of its type\n"
		"\n"
		""},
	 { "DiscreteVariable___repr__", _wrap_DiscreteVariable___repr__, METH_O, NULL},
	 { "DiscreteVariable___str__", _wrap_DiscreteVariable___str__, METH_O, NULL},
	 { "DiscreteVariable_asLabelizedVar", _wrap_DiscreteVariable_asLabelizedVar, METH_O, "\n"
		"\n"
		"Tries to cast the variable as a `gum.LabelizedVar`.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed if this is not possible\n"
		"\n"
		"Returns\n"
		"-------\n"
		"gum.LabelizedVar\n"
		"  the variable as a gum.LabelizedVar\n"
		"\n"
		""},
	 { "DiscreteVariable_asRangeVar", _wrap_DiscreteVariable_asRangeVar, METH_O, "\n"
		"\n"
		"Tries to cast the variable as a `gum.RangeVar`.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed if this is not possible\n"
		"\n"
		"Returns\n"
		"-------\n"
		"gum.RangeVar\n"
		"  the variable as a gum.RangeVar\n"
		"\n"
		""},
	 { "DiscreteVariable_asIntegerVar", _wrap_DiscreteVariable_asIntegerVar, METH_O, "\n"
		"\n"
		"Tries to cast the variable as a `gum.IntegerVar`.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed if this is not possible\n"
		"\n"
		"Returns\n"
		"-------\n"
		"gum.IntegerVar\n"
		"  the variable as a gum.IntegerVar\n"
		"\n"
		""},
	 { "DiscreteVariable_asNumericalDiscreteVar", _wrap_DiscreteVariable_asNumericalDiscreteVar, METH_O, "\n"
		"\n"
		"Tries to cast the variable as a `gum.NumericalDiscreteVar`.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed if this is not possible\n"
		"\n"
		"Returns\n"
		"-------\n"
		"gum.NumericalDiscreteVar\n"
		"  the variable as a gum.NumericalDiscreteVar\n"
		"\n"
		""},
	 { "DiscreteVariable_asDiscretizedVar", _wrap_DiscreteVariable_asDiscretizedVar, METH_O, "\n"
		"\n"
		"Tries to cast the variable as a `gum.DiscretizedVar`.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed if this is not possible\n"
		"\n"
		"Returns\n"
		"-------\n"
		"gum.DiscretizedVar\n"
		"  the variable as a gum.DiscretizedVar\n"
		"\n"
		""},
	 { "DiscreteVariable_swigregister", DiscreteVariable_swigregister, METH_O, NULL},
	 { "new_LabelizedVariable", _wrap_new_LabelizedVariable, METH_VARARGS, NULL},
	 { "delete_LabelizedVariable", _wrap_delete_LabelizedVariable, METH_O, NULL},
	 { "LabelizedVariable_clone", _wrap_LabelizedVariable_clone, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.LabelizedVariable\n"
		"	a copy of the LabelizedVariable\n"
		"\n"
		""},
	 { "LabelizedVariable_index", _wrap_LabelizedVariable_index, METH_VARARGS, "\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"
		"\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, NULL},
	 { "LabelizedVariable_changeLabel", _wrap_LabelizedVariable_changeLabel, METH_VARARGS, "\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"
		"pyagrum.DuplicateElement\n"
		"  If the variable already contains the new label\n"
		"pyagrum.OutOfBounds\n"
		"  If the index is greater than the size of the variable\n"
		"\n"
		""},
	 { "LabelizedVariable_eraseLabels", _wrap_LabelizedVariable_eraseLabels, METH_O, "\n"
		"\n"
		"Erase all the labels from the variable.\n"
		"\n"
		""},
	 { "LabelizedVariable_label", _wrap_LabelizedVariable_label, METH_VARARGS, "\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"
		"pyagrum.OutOfBounds\n"
		"	If the variable does not contain the label\n"
		"\n"
		""},
	 { "LabelizedVariable_posLabel", _wrap_LabelizedVariable_posLabel, METH_VARARGS, NULL},
	 { "LabelizedVariable_numerical", _wrap_LabelizedVariable_numerical, METH_VARARGS, "\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_closestIndex", _wrap_LabelizedVariable_closestIndex, METH_VARARGS, "\n"
		"\n"
		"For numerical discrete variables (all except :class:`gum.LabelizedVariable`), this method returns the index of the closest value to a given float value in the variable's domain.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value : float\n"
		"  the value for which we want to find the closest index\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the index of the closest value to `value` in the variable's domain\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotImplementedYet\n"
		"  if the variable is not numerical discrete (i.e., if it is a :class:`gum.LabelizedVariable`).\n"
		"\n"
		""},
	 { "LabelizedVariable_domainSize", _wrap_LabelizedVariable_domainSize, METH_O, "\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"
		"\n"
		"returns the type of variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	the type of the variable.\n"
		"\n"
		"	0: DiscretizedVariable, 1: LabelizedVariable, 2: IntegerVariable, 3: RangeVariable, 4:\n"
		"\n"
		""},
	 { "LabelizedVariable_domain", _wrap_LabelizedVariable_domain, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    the domain of the variable as a string\n"
		"\n"
		""},
	 { "LabelizedVariable_stype", _wrap_LabelizedVariable_stype, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	a description of its type\n"
		"\n"
		""},
	 { "LabelizedVariable_toFast", _wrap_LabelizedVariable_toFast, METH_O, NULL},
	 { "LabelizedVariable___repr__", _wrap_LabelizedVariable___repr__, METH_O, NULL},
	 { "LabelizedVariable___str__", _wrap_LabelizedVariable___str__, METH_O, NULL},
	 { "LabelizedVariable_swigregister", LabelizedVariable_swigregister, METH_O, NULL},
	 { "LabelizedVariable_swiginit", LabelizedVariable_swiginit, METH_VARARGS, NULL},
	 { "new_RangeVariable", _wrap_new_RangeVariable, METH_VARARGS, NULL},
	 { "delete_RangeVariable", _wrap_delete_RangeVariable, METH_O, NULL},
	 { "RangeVariable_clone", _wrap_RangeVariable_clone, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.RangeVariable\n"
		"	a copy of the RangeVariable\n"
		"\n"
		""},
	 { "RangeVariable_domainSize", _wrap_RangeVariable_domainSize, METH_O, "\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"
		"\n"
		"returns the type of variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	the type of the variable.\n"
		"\n"
		"	0: DiscretizedVariable, 1: LabelizedVariable, 2: IntegerVariable, 3: RangeVariable, 4:\n"
		"\n"
		""},
	 { "RangeVariable_toFast", _wrap_RangeVariable_toFast, METH_O, NULL},
	 { "RangeVariable_label", _wrap_RangeVariable_label, METH_VARARGS, "\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"
		"pyagrum.OutOfBounds\n"
		"  If the variable does not contain the label\n"
		"\n"
		""},
	 { "RangeVariable_numerical", _wrap_RangeVariable_numerical, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"long :\n"
		"  the lower bound of the variable\n"
		"\n"
		""},
	 { "RangeVariable_setMinVal", _wrap_RangeVariable_setMinVal, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"long :\n"
		"  the upper bound of the variable.\n"
		"\n"
		""},
	 { "RangeVariable_setMaxVal", _wrap_RangeVariable_setMaxVal, METH_VARARGS, "\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"
		"\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"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2 : str\n"
		"  a label\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the indice of the label\n"
		"\n"
		""},
	 { "RangeVariable_closestIndex", _wrap_RangeVariable_closestIndex, METH_VARARGS, "\n"
		"\n"
		"For numerical discrete variables (all except :class:`gum.LabelizedVariable`), this method returns the index of the closest value to a given float value in the variable's domain.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value : float\n"
		"  the value for which we want to find the closest index\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the index of the closest value to `value` in the variable's domain\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotImplementedYet\n"
		"  if the variable is not numerical discrete (i.e., if it is a :class:`gum.LabelizedVariable`).\n"
		"\n"
		""},
	 { "RangeVariable_domain", _wrap_RangeVariable_domain, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the domain of the variable\n"
		"\n"
		""},
	 { "RangeVariable_stype", _wrap_RangeVariable_stype, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	a description of its type\n"
		"\n"
		""},
	 { "RangeVariable___repr__", _wrap_RangeVariable___repr__, METH_O, NULL},
	 { "RangeVariable___str__", _wrap_RangeVariable___str__, METH_O, NULL},
	 { "RangeVariable_swigregister", RangeVariable_swigregister, METH_O, NULL},
	 { "RangeVariable_swiginit", RangeVariable_swiginit, METH_VARARGS, NULL},
	 { "new_IntegerVariable", _wrap_new_IntegerVariable, METH_VARARGS, NULL},
	 { "IntegerVariable_clone", _wrap_IntegerVariable_clone, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  pyagrum.DiscreteVariable\n"
		"	a copy of the DiscreteVariable\n"
		"\n"
		""},
	 { "delete_IntegerVariable", _wrap_delete_IntegerVariable, METH_O, NULL},
	 { "IntegerVariable_domainSize", _wrap_IntegerVariable_domainSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of modalities in the variable domain\n"
		"\n"
		""},
	 { "IntegerVariable_varType", _wrap_IntegerVariable_varType, METH_O, "\n"
		"\n"
		"returns the type of variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	the type of the variable.\n"
		"\n"
		"	0: DiscretizedVariable, 1: LabelizedVariable, 2: IntegerVariable, 3: RangeVariable, 4:\n"
		"\n"
		""},
	 { "IntegerVariable_toFast", _wrap_IntegerVariable_toFast, METH_O, NULL},
	 { "IntegerVariable_index", _wrap_IntegerVariable_index, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"label : str\n"
		"	a label\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the indice of the label\n"
		"\n"
		""},
	 { "IntegerVariable_closestIndex", _wrap_IntegerVariable_closestIndex, METH_VARARGS, "\n"
		"\n"
		"For numerical discrete variables (all except :class:`gum.LabelizedVariable`), this method returns the index of the closest value to a given float value in the variable's domain.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value : float\n"
		"  the value for which we want to find the closest index\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the index of the closest value to `value` in the variable's domain\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotImplementedYet\n"
		"  if the variable is not numerical discrete (i.e., if it is a :class:`gum.LabelizedVariable`).\n"
		"\n"
		""},
	 { "IntegerVariable_label", _wrap_IntegerVariable_label, METH_VARARGS, "\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"
		"pyagrum.OutOfBounds\n"
		"	If the variable does not contain the label\n"
		"\n"
		""},
	 { "IntegerVariable_numerical", _wrap_IntegerVariable_numerical, METH_VARARGS, "\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"
		""},
	 { "IntegerVariable_domain", _wrap_IntegerVariable_domain, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the domain of the variable\n"
		"\n"
		""},
	 { "IntegerVariable_stype", _wrap_IntegerVariable_stype, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	a description of its type\n"
		"\n"
		""},
	 { "IntegerVariable_integerDomain", _wrap_IntegerVariable_integerDomain, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tuple[int]\n"
		"    the tuple of integer values that form the domain of this variable\n"
		"\n"
		""},
	 { "IntegerVariable_addValue", _wrap_IntegerVariable_addValue, METH_VARARGS, NULL},
	 { "IntegerVariable_isValue", _wrap_IntegerVariable_isValue, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int\n"
		"    the value to look at.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the value is in the domain.\n"
		"\n"
		""},
	 { "IntegerVariable_changeValue", _wrap_IntegerVariable_changeValue, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"old_value : int\n"
		"    the value to be changed\n"
		"\n"
		"new_value : int\n"
		"    the new value\n"
		"\n"
		""},
	 { "IntegerVariable_eraseValue", _wrap_IntegerVariable_eraseValue, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int\n"
		"    the value to erase. If the value is not in the domain, the function does nothing (no exception raised)\n"
		"\n"
		""},
	 { "IntegerVariable_eraseValues", _wrap_IntegerVariable_eraseValues, METH_O, "\n"
		"\n"
		"Remove all the domain.\n"
		"\n"
		""},
	 { "IntegerVariable_closestLabel", _wrap_IntegerVariable_closestLabel, METH_VARARGS, "\n"
		"\n"
		"For numerical discrete variables (all except :class:`gum.LabelizedVariable`), this method returns the label of the closest value to a given float value in the variable's domain.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value : float\n"
		"  the value for which we want to find the closest index\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"  the label of the closest value to `value` in the variable's domain\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  if the variable is not numerical discrete (i.e., if it is a :class:`gum.LabelizedVariable`).\n"
		"\n"
		""},
	 { "IntegerVariable___repr__", _wrap_IntegerVariable___repr__, METH_O, NULL},
	 { "IntegerVariable___str__", _wrap_IntegerVariable___str__, METH_O, NULL},
	 { "IntegerVariable_swigregister", IntegerVariable_swigregister, METH_O, NULL},
	 { "IntegerVariable_swiginit", IntegerVariable_swiginit, METH_VARARGS, NULL},
	 { "new_NumericalDiscreteVariable", _wrap_new_NumericalDiscreteVariable, METH_VARARGS, NULL},
	 { "NumericalDiscreteVariable_clone", _wrap_NumericalDiscreteVariable_clone, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  pyagrum.DiscreteVariable\n"
		"	a copy of the DiscreteVariable\n"
		"\n"
		""},
	 { "delete_NumericalDiscreteVariable", _wrap_delete_NumericalDiscreteVariable, METH_O, NULL},
	 { "NumericalDiscreteVariable_domainSize", _wrap_NumericalDiscreteVariable_domainSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of modalities in the variable domain\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable_varType", _wrap_NumericalDiscreteVariable_varType, METH_O, "\n"
		"\n"
		"returns the type of variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	the type of the variable.\n"
		"\n"
		"	0: DiscretizedVariable, 1: LabelizedVariable, 2: IntegerVariable, 3: RangeVariable, 4:\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable_toFast", _wrap_NumericalDiscreteVariable_toFast, METH_O, NULL},
	 { "NumericalDiscreteVariable_index", _wrap_NumericalDiscreteVariable_index, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"label : str\n"
		"	a label\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the indice of the label\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable_closestIndex", _wrap_NumericalDiscreteVariable_closestIndex, METH_VARARGS, "\n"
		"\n"
		"For numerical discrete variables (all except :class:`gum.LabelizedVariable`), this method returns the index of the closest value to a given float value in the variable's domain.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value : float\n"
		"  the value for which we want to find the closest index\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the index of the closest value to `value` in the variable's domain\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotImplementedYet\n"
		"  if the variable is not numerical discrete (i.e., if it is a :class:`gum.LabelizedVariable`).\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable_label", _wrap_NumericalDiscreteVariable_label, METH_VARARGS, "\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"
		"pyagrum.OutOfBounds\n"
		"	If the variable does not contain the label\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable_numerical", _wrap_NumericalDiscreteVariable_numerical, METH_VARARGS, "\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"
		""},
	 { "NumericalDiscreteVariable_domain", _wrap_NumericalDiscreteVariable_domain, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the domain of the variable\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable_stype", _wrap_NumericalDiscreteVariable_stype, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	a description of its type\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable_numericalDomain", _wrap_NumericalDiscreteVariable_numericalDomain, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tuple[float]\n"
		"    the tuple of float values that form the domain of this variable\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable_addValue", _wrap_NumericalDiscreteVariable_addValue, METH_VARARGS, NULL},
	 { "NumericalDiscreteVariable_isValue", _wrap_NumericalDiscreteVariable_isValue, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int\n"
		"    the value to look at.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the value is in the domain.\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable_changeValue", _wrap_NumericalDiscreteVariable_changeValue, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"old_value : int\n"
		"    the value to be changed\n"
		"\n"
		"new_value : int\n"
		"    the new value\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable_eraseValue", _wrap_NumericalDiscreteVariable_eraseValue, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int\n"
		"    the value to erase. If the value is not in the domain, the function does nothing (no exception raised)\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable_eraseValues", _wrap_NumericalDiscreteVariable_eraseValues, METH_O, "\n"
		"\n"
		"Remove all the domain.\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable_closestLabel", _wrap_NumericalDiscreteVariable_closestLabel, METH_VARARGS, "\n"
		"\n"
		"For numerical discrete variables (all except :class:`gum.LabelizedVariable`), this method returns the label of the closest value to a given float value in the variable's domain.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value : float\n"
		"  the value for which we want to find the closest index\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"  the label of the closest value to `value` in the variable's domain\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  if the variable is not numerical discrete (i.e., if it is a :class:`gum.LabelizedVariable`).\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable___repr__", _wrap_NumericalDiscreteVariable___repr__, METH_O, NULL},
	 { "NumericalDiscreteVariable___str__", _wrap_NumericalDiscreteVariable___str__, METH_O, NULL},
	 { "NumericalDiscreteVariable_swigregister", NumericalDiscreteVariable_swigregister, METH_O, NULL},
	 { "NumericalDiscreteVariable_swiginit", NumericalDiscreteVariable_swiginit, METH_VARARGS, NULL},
	 { "delete_IDiscretizedVariable", _wrap_delete_IDiscretizedVariable, METH_O, NULL},
	 { "IDiscretizedVariable_clone", _wrap_IDiscretizedVariable_clone, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  pyagrum.DiscreteVariable\n"
		"	a copy of the DiscreteVariable\n"
		"\n"
		""},
	 { "IDiscretizedVariable_isEmpirical", _wrap_IDiscretizedVariable_isEmpirical, METH_O, NULL},
	 { "IDiscretizedVariable_setEmpirical", _wrap_IDiscretizedVariable_setEmpirical, METH_VARARGS, NULL},
	 { "IDiscretizedVariable_draw", _wrap_IDiscretizedVariable_draw, METH_VARARGS, NULL},
	 { "IDiscretizedVariable_swigregister", IDiscretizedVariable_swigregister, METH_O, NULL},
	 { "new_Edge", _wrap_new_Edge, METH_VARARGS, NULL},
	 { "delete_Edge", _wrap_delete_Edge, METH_O, NULL},
	 { "Edge_other", _wrap_Edge_other, METH_VARARGS, "\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"
		"\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"
		"\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, NULL},
	 { "Edge_swigregister", Edge_swigregister, METH_O, NULL},
	 { "Edge_swiginit", Edge_swiginit, METH_VARARGS, NULL},
	 { "new_Arc", _wrap_new_Arc, METH_VARARGS, NULL},
	 { "delete_Arc", _wrap_delete_Arc, METH_O, NULL},
	 { "Arc_tail", _wrap_Arc_tail, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the id of the tail node\n"
		"\n"
		""},
	 { "Arc_head", _wrap_Arc_head, METH_O, "\n"
		"\n"
		"Returns\n"
		"------\n"
		"int\n"
		"  the id of the head node\n"
		"\n"
		""},
	 { "Arc_other", _wrap_Arc_other, METH_VARARGS, "\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"
		"\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"
		"\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, NULL},
	 { "Arc_swigregister", Arc_swigregister, METH_O, NULL},
	 { "Arc_swiginit", Arc_swiginit, METH_VARARGS, NULL},
	 { "new_UndiGraph", _wrap_new_UndiGraph, METH_VARARGS, NULL},
	 { "delete_UndiGraph", _wrap_delete_UndiGraph, METH_O, NULL},
	 { "UndiGraph_completeGraph", _wrap_UndiGraph_completeGraph, METH_O, NULL},
	 { "UndiGraph___eq__", _wrap_UndiGraph___eq__, METH_VARARGS, NULL},
	 { "UndiGraph___ne__", _wrap_UndiGraph___ne__, METH_VARARGS, NULL},
	 { "UndiGraph_eraseNode", _wrap_UndiGraph_eraseNode, METH_VARARGS, "\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"
		"\n"
		"Remove all the nodes and edges from the graph.\n"
		"\n"
		""},
	 { "UndiGraph_toDot", _wrap_UndiGraph_toDot, METH_O, "\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"
		"\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"
		"\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_nodes2ConnectedComponent", _wrap_UndiGraph_nodes2ConnectedComponent, METH_O, NULL},
	 { "UndiGraph___repr__", _wrap_UndiGraph___repr__, METH_O, NULL},
	 { "UndiGraph___str__", _wrap_UndiGraph___str__, METH_O, NULL},
	 { "UndiGraph_nodes", _wrap_UndiGraph_nodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of ids\n"
		"\n"
		""},
	 { "UndiGraph_addNodes", _wrap_UndiGraph_addNodes, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"  the list of the edges\n"
		"\n"
		""},
	 { "UndiGraph_neighbours", _wrap_UndiGraph_neighbours, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the new NodeId\n"
		"\n"
		""},
	 { "UndiGraph_addNodeWithId", _wrap_UndiGraph_addNodeWithId, METH_VARARGS, "\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"
		"  pyagrum.DuplicateElement\n"
		"    If the given id is already used\n"
		"\n"
		""},
	 { "UndiGraph_existsNode", _wrap_UndiGraph_existsNode, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of nodes in the graph\n"
		"\n"
		""},
	 { "UndiGraph_empty", _wrap_UndiGraph_empty, METH_O, "\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"
		"\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"
		"  pyagrum.InvalidNode\n"
		"    If n1 or n2 does not belong to the graph nodes.\n"
		"\n"
		""},
	 { "UndiGraph_eraseEdge", _wrap_UndiGraph_eraseEdge, METH_VARARGS, "\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"
		"\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of edges in the graph\n"
		"\n"
		""},
	 { "UndiGraph_emptyEdges", _wrap_UndiGraph_emptyEdges, METH_O, "\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"
		"\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_O, NULL},
	 { "UndiGraph_swiginit", UndiGraph_swiginit, METH_VARARGS, NULL},
	 { "new_DiGraph", _wrap_new_DiGraph, METH_VARARGS, NULL},
	 { "delete_DiGraph", _wrap_delete_DiGraph, METH_O, NULL},
	 { "DiGraph_completeGraph", _wrap_DiGraph_completeGraph, METH_O, NULL},
	 { "DiGraph___eq__", _wrap_DiGraph___eq__, METH_VARARGS, NULL},
	 { "DiGraph_eraseNode", _wrap_DiGraph_eraseNode, METH_VARARGS, "\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"
		"\n"
		"Remove all the nodes and arcs from the graph.\n"
		"\n"
		""},
	 { "DiGraph_toDot", _wrap_DiGraph_toDot, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format\n"
		"\n"
		""},
	 { "DiGraph_topologicalOrder", _wrap_DiGraph_topologicalOrder, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"    the list of the nodes Ids in a topological order\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidDirectedCycle\n"
		"  If this graph contains cycles\n"
		"\n"
		""},
	 { "DiGraph_hasDirectedPath", _wrap_DiGraph_hasDirectedPath, METH_VARARGS, "\n"
		"\n"
		"Check if a directedpath exists bewteen from and to.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"from : int\n"
		"	the id of the first node of the (possible) path\n"
		"to : int\n"
		"	the id of the last node of the (possible) path\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the directed path exists\n"
		"\n"
		""},
	 { "DiGraph___repr__", _wrap_DiGraph___repr__, METH_O, NULL},
	 { "DiGraph___str__", _wrap_DiGraph___str__, METH_O, NULL},
	 { "DiGraph_nodes", _wrap_DiGraph_nodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of ids\n"
		"\n"
		""},
	 { "DiGraph_addNodes", _wrap_DiGraph_addNodes, METH_VARARGS, "\n"
		"\n"
		"Add a set of 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"
		"\n"
		"Returns the set of arcs in the graph.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"	the set of the arcs\n"
		"\n"
		""},
	 { "DiGraph_parents", _wrap_DiGraph_parents, METH_VARARGS, "\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"
		"\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the new NodeId\n"
		"\n"
		""},
	 { "DiGraph_addNodeWithId", _wrap_DiGraph_addNodeWithId, METH_VARARGS, "\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"
		"  pyagrum.DuplicateElement\n"
		"  If the given id is already used\n"
		"\n"
		""},
	 { "DiGraph_existsNode", _wrap_DiGraph_existsNode, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of nodes in the graph\n"
		"\n"
		""},
	 { "DiGraph_empty", _wrap_DiGraph_empty, METH_O, "\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"
		"\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"
		"  pyagrum.InvalidNode\n"
		"    If head or tail does not belong to the graph nodes.\n"
		"\n"
		""},
	 { "DiGraph_eraseArc", _wrap_DiGraph_eraseArc, METH_VARARGS, "\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of arcs in the graph\n"
		"\n"
		""},
	 { "DiGraph_emptyArcs", _wrap_DiGraph_emptyArcs, METH_O, "\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_O, NULL},
	 { "DiGraph_swiginit", DiGraph_swiginit, METH_VARARGS, NULL},
	 { "new_DAG", _wrap_new_DAG, METH_VARARGS, NULL},
	 { "delete_DAG", _wrap_delete_DAG, METH_O, NULL},
	 { "DAG_moralGraph", _wrap_DAG_moralGraph, METH_O, NULL},
	 { "DAG_minimalCondSet", _wrap_DAG_minimalCondSet, METH_VARARGS, NULL},
	 { "DAG___repr__", _wrap_DAG___repr__, METH_O, NULL},
	 { "DAG___str__", _wrap_DAG___str__, METH_O, NULL},
	 { "DAG_dSeparation", _wrap_DAG_dSeparation, METH_VARARGS, "\n"
		"\n"
		"Check if the sets of nodes X and Y are d-separated (by the set of nodes Z if given) in the DAG.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int | sequence of int\n"
		"  a sequence of node ids (int) or a single node id (int)\n"
		"Y : int | sequence of int\n"
		"  a sequence of node ids (int) or a single node id (int)\n"
		"Z : int | sequence of int (optional)\n"
		"  a sequence of node ids (int) or a single node id (int)\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if X and Y are d-separated (by Z if given), False otherwise.\n"
		"\n"
		""},
	 { "DAG_moralizedAncestralGraph", _wrap_DAG_moralizedAncestralGraph, METH_VARARGS, "\n"
		"\n"
		"Compute the moralized ancestral graph of the nodes from the DAG.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nodes : int | sequence of int\n"
		"  a sequence of node ids (int) or a single node id (int)\n"
		"Returns\n"
		"------- \n"
		"gum::UndiGraph\n"
		"  the moralized ancestral graph of the nodes from the DAG.\n"
		"\n"
		""},
	 { "DAG_addNodes", _wrap_DAG_addNodes, METH_VARARGS, "\n"
		"\n"
		"Add a set of 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"
		""},
	 { "DAG_arcs", _wrap_DAG_arcs, METH_O, "\n"
		"\n"
		"Returns the set of arcs in the graph.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"	the set of the arcs\n"
		"\n"
		""},
	 { "DAG_parents", _wrap_DAG_parents, METH_VARARGS, "\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"
		""},
	 { "DAG_children", _wrap_DAG_children, METH_VARARGS, "\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"
		""},
	 { "DAG_addArc", _wrap_DAG_addArc, METH_VARARGS, "\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"
		"  pyagrum.InvalidNode\n"
		"    If head or tail does not belong to the graph nodes.\n"
		"  pyagrum.CycleDetected\n"
		"    If a cycle is detected\n"
		"\n"
		"\n"
		""},
	 { "DAG_eraseArc", _wrap_DAG_eraseArc, METH_VARARGS, "\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"
		""},
	 { "DAG_existsArc", _wrap_DAG_existsArc, METH_VARARGS, "\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"
		""},
	 { "DAG_eraseParents", _wrap_DAG_eraseParents, METH_VARARGS, "\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"
		""},
	 { "DAG_eraseChildren", _wrap_DAG_eraseChildren, METH_VARARGS, "\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"
		""},
	 { "DAG_sizeArcs", _wrap_DAG_sizeArcs, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of arcs in the graph\n"
		"\n"
		""},
	 { "DAG_emptyArcs", _wrap_DAG_emptyArcs, METH_O, "\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"
		""},
	 { "DAG_swigregister", DAG_swigregister, METH_O, NULL},
	 { "DAG_swiginit", DAG_swiginit, METH_VARARGS, NULL},
	 { "new_MixedGraph", _wrap_new_MixedGraph, METH_VARARGS, NULL},
	 { "delete_MixedGraph", _wrap_delete_MixedGraph, METH_O, NULL},
	 { "MixedGraph___eq__", _wrap_MixedGraph___eq__, METH_VARARGS, NULL},
	 { "MixedGraph_eraseNode", _wrap_MixedGraph_eraseNode, METH_VARARGS, "\n"
		"\n"
		"Erase the node and all the related arcs and edges.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	the id of the node\n"
		"\n"
		""},
	 { "MixedGraph_clear", _wrap_MixedGraph_clear, METH_O, "\n"
		"\n"
		"Remove all the nodes and edges from the graph.\n"
		"\n"
		""},
	 { "MixedGraph_hasMixedOrientedPath", _wrap_MixedGraph_hasMixedOrientedPath, METH_VARARGS, NULL},
	 { "MixedGraph_toDot", _wrap_MixedGraph_toDot, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format\n"
		"\n"
		""},
	 { "MixedGraph_chainComponent", _wrap_MixedGraph_chainComponent, METH_VARARGS, NULL},
	 { "MixedGraph___repr__", _wrap_MixedGraph___repr__, METH_O, NULL},
	 { "MixedGraph___str__", _wrap_MixedGraph___str__, METH_O, NULL},
	 { "MixedGraph_addNodes", _wrap_MixedGraph_addNodes, METH_VARARGS, "\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"
		""},
	 { "MixedGraph_arcs", _wrap_MixedGraph_arcs, METH_O, NULL},
	 { "MixedGraph_parents", _wrap_MixedGraph_parents, METH_VARARGS, NULL},
	 { "MixedGraph_children", _wrap_MixedGraph_children, METH_VARARGS, NULL},
	 { "MixedGraph_edges", _wrap_MixedGraph_edges, METH_O, NULL},
	 { "MixedGraph_neighbours", _wrap_MixedGraph_neighbours, METH_VARARGS, NULL},
	 { "MixedGraph_boundary", _wrap_MixedGraph_boundary, METH_VARARGS, "\n"
		"\n"
		"Boundary are neighbours (not oriented), children and parents\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	the id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of node ids.\n"
		"\n"
		""},
	 { "MixedGraph_mixedOrientedPath", _wrap_MixedGraph_mixedOrientedPath, METH_VARARGS, "\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). If no path is found, the returned list is empty.\n"
		"\n"
		""},
	 { "MixedGraph_mixedUnorientedPath", _wrap_MixedGraph_mixedUnorientedPath, METH_VARARGS, "\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). If no path is found, the list is empty.\n"
		"\n"
		"\n"
		""},
	 { "MixedGraph_addNode", _wrap_MixedGraph_addNode, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the new NodeId\n"
		"\n"
		""},
	 { "MixedGraph_addNodeWithId", _wrap_MixedGraph_addNodeWithId, METH_VARARGS, "\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"
		"  pyagrum.DuplicateElement\n"
		"    If the given id is already used\n"
		"\n"
		""},
	 { "MixedGraph_existsNode", _wrap_MixedGraph_existsNode, METH_VARARGS, "\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"
		""},
	 { "MixedGraph_size", _wrap_MixedGraph_size, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of nodes in the graph\n"
		"\n"
		""},
	 { "MixedGraph_empty", _wrap_MixedGraph_empty, METH_O, "\n"
		"\n"
		"Check if the graph is empty.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the graph is empty\n"
		"\n"
		""},
	 { "MixedGraph_addEdge", _wrap_MixedGraph_addEdge, METH_VARARGS, "\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"
		"  pyagrum.InvalidNode\n"
		"    If n1 or n2 does not belong to the graph nodes.\n"
		"\n"
		""},
	 { "MixedGraph_eraseEdge", _wrap_MixedGraph_eraseEdge, METH_VARARGS, "\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"
		""},
	 { "MixedGraph_existsEdge", _wrap_MixedGraph_existsEdge, METH_VARARGS, "\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"
		""},
	 { "MixedGraph_sizeEdges", _wrap_MixedGraph_sizeEdges, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of edges in the graph\n"
		"\n"
		""},
	 { "MixedGraph_emptyEdges", _wrap_MixedGraph_emptyEdges, METH_O, "\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"
		""},
	 { "MixedGraph_eraseNeighbours", _wrap_MixedGraph_eraseNeighbours, METH_VARARGS, "\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"
		""},
	 { "MixedGraph_addArc", _wrap_MixedGraph_addArc, METH_VARARGS, NULL},
	 { "MixedGraph_eraseArc", _wrap_MixedGraph_eraseArc, METH_VARARGS, "\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"
		""},
	 { "MixedGraph_existsArc", _wrap_MixedGraph_existsArc, METH_VARARGS, "\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"
		""},
	 { "MixedGraph_eraseParents", _wrap_MixedGraph_eraseParents, METH_VARARGS, "\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"
		""},
	 { "MixedGraph_eraseChildren", _wrap_MixedGraph_eraseChildren, METH_VARARGS, "\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"
		""},
	 { "MixedGraph_sizeArcs", _wrap_MixedGraph_sizeArcs, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of arcs in the graph\n"
		"\n"
		""},
	 { "MixedGraph_emptyArcs", _wrap_MixedGraph_emptyArcs, METH_O, "\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"
		""},
	 { "MixedGraph_swigregister", MixedGraph_swigregister, METH_O, NULL},
	 { "MixedGraph_swiginit", MixedGraph_swiginit, METH_VARARGS, NULL},
	 { "new_PDAG", _wrap_new_PDAG, METH_VARARGS, NULL},
	 { "delete_PDAG", _wrap_delete_PDAG, METH_O, NULL},
	 { "PDAG_moralGraph", _wrap_PDAG_moralGraph, METH_O, NULL},
	 { "PDAG_hasMixedReallyOrientedPath", _wrap_PDAG_hasMixedReallyOrientedPath, METH_VARARGS, NULL},
	 { "PDAG_toDot", _wrap_PDAG_toDot, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format\n"
		"\n"
		""},
	 { "PDAG___repr__", _wrap_PDAG___repr__, METH_O, NULL},
	 { "PDAG___str__", _wrap_PDAG___str__, METH_O, NULL},
	 { "PDAG_cSeparation", _wrap_PDAG_cSeparation, METH_VARARGS, "\n"
		"\n"
		"Check if the sets of nodes X and Y are c-separated (by the set of nodes Z if given) in the PDAG.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int | sequence of int\n"
		"  a sequence of node ids (int) or a single node id (int)\n"
		"Y : int | sequence of int\n"
		"  a sequence of node ids (int) or a single node id (int)\n"
		"Z : int | sequence of int (optional)\n"
		"  a sequence of node ids (int) or a single node id (int)\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if X and Y are c-separated (by Z if given), False otherwise.\n"
		"\n"
		""},
	 { "PDAG_moralizedAncestralGraph", _wrap_PDAG_moralizedAncestralGraph, METH_VARARGS, "\n"
		"\n"
		"Compute the moralized ancestral graph of the nodes from the DAG.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nodes : int | sequence of int\n"
		"  a sequence of node ids (int) or a single node id (int)\n"
		"Returns\n"
		"------- \n"
		"gum::UndiGraph\n"
		"  the moralized ancestral graph of the nodes from the DAG.\n"
		"\n"
		""},
	 { "PDAG_addNodes", _wrap_PDAG_addNodes, METH_VARARGS, NULL},
	 { "PDAG_arcs", _wrap_PDAG_arcs, METH_O, NULL},
	 { "PDAG_parents", _wrap_PDAG_parents, METH_VARARGS, NULL},
	 { "PDAG_children", _wrap_PDAG_children, METH_VARARGS, NULL},
	 { "PDAG_edges", _wrap_PDAG_edges, METH_O, NULL},
	 { "PDAG_neighbours", _wrap_PDAG_neighbours, METH_VARARGS, NULL},
	 { "PDAG_boundary", _wrap_PDAG_boundary, METH_VARARGS, NULL},
	 { "PDAG_mixedOrientedPath", _wrap_PDAG_mixedOrientedPath, METH_VARARGS, "\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). If no path is found, the returned list is empty.\n"
		"\n"
		""},
	 { "PDAG_mixedUnorientedPath", _wrap_PDAG_mixedUnorientedPath, METH_VARARGS, "\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). If no path is found, the list is empty.\n"
		"\n"
		"\n"
		""},
	 { "PDAG_addNode", _wrap_PDAG_addNode, METH_O, NULL},
	 { "PDAG_addNodeWithId", _wrap_PDAG_addNodeWithId, METH_VARARGS, NULL},
	 { "PDAG_existsNode", _wrap_PDAG_existsNode, METH_VARARGS, NULL},
	 { "PDAG_size", _wrap_PDAG_size, METH_O, NULL},
	 { "PDAG_empty", _wrap_PDAG_empty, METH_O, NULL},
	 { "PDAG_addEdge", _wrap_PDAG_addEdge, METH_VARARGS, "\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"
		"  pyagrum.InvalidNode\n"
		"    If n1 or n2 does not belong to the graph nodes.\n"
		"\n"
		""},
	 { "PDAG_eraseEdge", _wrap_PDAG_eraseEdge, METH_VARARGS, NULL},
	 { "PDAG_existsEdge", _wrap_PDAG_existsEdge, METH_VARARGS, NULL},
	 { "PDAG_sizeEdges", _wrap_PDAG_sizeEdges, METH_O, NULL},
	 { "PDAG_emptyEdges", _wrap_PDAG_emptyEdges, METH_O, NULL},
	 { "PDAG_eraseNeighbours", _wrap_PDAG_eraseNeighbours, METH_VARARGS, NULL},
	 { "PDAG_addArc", _wrap_PDAG_addArc, METH_VARARGS, "\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"
		"  pyagrum.InvalidNode\n"
		"    If head or tail does not belong to the graph nodes.\n"
		"\n"
		"  PyAgrum.InvalidDirectedCycle\n"
		"    if the arc would create a (mixed) cycle.\n"
		"\n"
		""},
	 { "PDAG_eraseArc", _wrap_PDAG_eraseArc, METH_VARARGS, NULL},
	 { "PDAG_existsArc", _wrap_PDAG_existsArc, METH_VARARGS, NULL},
	 { "PDAG_eraseParents", _wrap_PDAG_eraseParents, METH_VARARGS, NULL},
	 { "PDAG_eraseChildren", _wrap_PDAG_eraseChildren, METH_VARARGS, NULL},
	 { "PDAG_sizeArcs", _wrap_PDAG_sizeArcs, METH_O, NULL},
	 { "PDAG_emptyArcs", _wrap_PDAG_emptyArcs, METH_O, NULL},
	 { "PDAG_swigregister", PDAG_swigregister, METH_O, NULL},
	 { "PDAG_swiginit", PDAG_swiginit, METH_VARARGS, NULL},
	 { "new_CliqueGraph", _wrap_new_CliqueGraph, METH_VARARGS, NULL},
	 { "delete_CliqueGraph", _wrap_delete_CliqueGraph, METH_O, NULL},
	 { "CliqueGraph_addEdge", _wrap_CliqueGraph_addEdge, METH_VARARGS, "\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"
		"  pyagrum.InvalidNode\n"
		"    If n1 or n2 does not belong to the graph nodes.\n"
		"\n"
		""},
	 { "CliqueGraph_eraseEdge", _wrap_CliqueGraph_eraseEdge, METH_VARARGS, "\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"
		"\n"
		"Remove all edges and their separators\n"
		"\n"
		""},
	 { "CliqueGraph_addNode", _wrap_CliqueGraph_addNode, METH_VARARGS, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the new NodeId\n"
		"\n"
		""},
	 { "CliqueGraph_eraseNode", _wrap_CliqueGraph_eraseNode, METH_VARARGS, "\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"
		"\n"
		"Remove all the nodes and edges from the graph.\n"
		"\n"
		""},
	 { "CliqueGraph_container", _wrap_CliqueGraph_container, METH_VARARGS, "\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"
		"pyagrum.NotFound\n"
		"  If no clique contains idNode\n"
		"\n"
		""},
	 { "CliqueGraph_setClique", _wrap_CliqueGraph_setClique, METH_VARARGS, "\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[int]\n"
		"  the new set of nodes to be included in the clique\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"  If idClique is not a clique of the graph\n"
		"\n"
		""},
	 { "CliqueGraph_addToClique", _wrap_CliqueGraph_addToClique, METH_VARARGS, "\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"
		"  pyagrum.NotFound\n"
		"  If clique_id does not exist\n"
		"  pyagrum.DuplicateElement\n"
		"  If clique_id set already contains the ndoe\n"
		"\n"
		""},
	 { "CliqueGraph_eraseFromClique", _wrap_CliqueGraph_eraseFromClique, METH_VARARGS, "\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"
		"pyagrum.NotFound\n"
		"  If clique_id does not exist\n"
		"\n"
		""},
	 { "CliqueGraph_containerPath", _wrap_CliqueGraph_containerPath, METH_VARARGS, "\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"
		"pyagrum.NotFound\n"
		"  If such path cannot be found\n"
		"\n"
		""},
	 { "CliqueGraph_hasRunningIntersection", _wrap_CliqueGraph_hasRunningIntersection, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if the running intersection property holds\n"
		"\n"
		""},
	 { "CliqueGraph_isJoinTree", _wrap_CliqueGraph_isJoinTree, METH_O, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format\n"
		"\n"
		""},
	 { "CliqueGraph___map_str__", _wrap_CliqueGraph___map_str__, METH_VARARGS, NULL},
	 { "CliqueGraph___eq__", _wrap_CliqueGraph___eq__, METH_VARARGS, NULL},
	 { "CliqueGraph_clique", _wrap_CliqueGraph_clique, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"idClique : int\n"
		"  the id of the clique\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  The set of nodes included in the clique\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"  If the clique does not belong to the clique graph\n"
		"\n"
		""},
	 { "CliqueGraph_separator", _wrap_CliqueGraph_separator, METH_VARARGS, "\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[int]\n"
		"  the separator included in a given edge\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"  If the edge does not belong to the clique graph\n"
		"\n"
		""},
	 { "CliqueGraph_swigregister", CliqueGraph_swigregister, METH_O, NULL},
	 { "CliqueGraph_swiginit", CliqueGraph_swiginit, METH_VARARGS, NULL},
	 { "new_MeekRules", _wrap_new_MeekRules, METH_NOARGS, NULL},
	 { "delete_MeekRules", _wrap_delete_MeekRules, METH_O, NULL},
	 { "MeekRules_propagate", _wrap_MeekRules_propagate, METH_VARARGS, NULL},
	 { "MeekRules_propagateToCPDAG", _wrap_MeekRules_propagateToCPDAG, METH_VARARGS, "\n"
		"\n"
		"Propagates orientation constraints in the graph according to the Meek rules. The Meek rules are applied iteratively until no more orientation constraints can be propagated. And then arbitratily resolves double orientations. This method returns a `pyagrum.PDAG` with the properties of CPDAG.\n"
		"\n"
		"The arbitrary resolution of double orientations is not deterministic. It depends on the order of the edges in the graph. `pyagrum.MeekRules.Choices` returns the list of the arbitrary choices made by the last execution of `pyagrum.MeekRules.progagatesToCPDAG`.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"mg : pyagrum.MixedGraph\n"
		"    The graph to be completed.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.PDAG\n"
		"    The completed `pyagrum.PDAG` (CPDAG).\n"
		"\n"
		""},
	 { "MeekRules_propagateToDAG", _wrap_MeekRules_propagateToDAG, METH_VARARGS, "\n"
		"\n"
		"Calls `propagateToCPDAG` and then orients the remaining edges arbitrarily according to some heuristics. `pyagrum.MeekRules.Choices` returns the list of the arbitrary choices made by the last execution of `pyagrum.MeekRules.progagatesToDAG`.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"mg : `pyagrum.MixedGraph` or `pyagrum.PDAG`\n"
		"    The graph to be completed.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"`pyagrum.DAG`\n"
		"    The completed `pyagrum.DAG`.\n"
		"\n"
		""},
	 { "MeekRules_choices", _wrap_MeekRules_choices, METH_O, "\n"
		"\n"
		"Returns the list of the arbitrary choices made by the last execution of `pyagrum.MeekRules.progagatesToCPDAG` or `pyagrum.MeekRules.progagatesToDAG`.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list of tuple\n"
		"    The list of the arbitrary choices made by the last execution of `pyagrum.MeekRules.progagatesToCPDAG` or `pyagrum.MeekRules.progagatesToDAG`. Each tuple represents a `pyagrum.Edge`.\n"
		"\n"
		""},
	 { "MeekRules_swigregister", MeekRules_swigregister, METH_O, NULL},
	 { "MeekRules_swiginit", MeekRules_swiginit, METH_VARARGS, NULL},
	 { "new_Instantiation", _wrap_new_Instantiation, METH_VARARGS, NULL},
	 { "delete_Instantiation", _wrap_delete_Instantiation, METH_O, NULL},
	 { "Instantiation_nbrDim", _wrap_Instantiation_nbrDim, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    The number of variables in the Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_add", _wrap_Instantiation_add, METH_VARARGS, "\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"
		"\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"
		"\n"
		"Erase all variables from an Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_domainSize", _wrap_Instantiation_domainSize, METH_O, "\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"OutOfBounds\n"
		"  If newval is not a possible value for the variable.\n"
		"\n"
		""},
	 { "Instantiation_setVals", _wrap_Instantiation_setVals, METH_VARARGS, "\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"
		"\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"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"    the sequence of DiscreteVariable of this instantiation.\n"
		"\n"
		""},
	 { "Instantiation_empty", _wrap_Instantiation_empty, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the instantiation is empty.\n"
		"\n"
		""},
	 { "Instantiation_inOverflow", _wrap_Instantiation_inOverflow, METH_O, "\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"
		"\n"
		"Removes the flag overflow.\n"
		"\n"
		""},
	 { "Instantiation_unsetEnd", _wrap_Instantiation_unsetEnd, METH_O, "\n"
		"\n"
		"Alias for unsetOverflow().\n"
		"\n"
		""},
	 { "Instantiation_end", _wrap_Instantiation_end, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the Instantiation reached the end.\n"
		"\n"
		""},
	 { "Instantiation_rend", _wrap_Instantiation_rend, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool:\n"
		"  True if the Instantiation reached the rend.\n"
		"\n"
		""},
	 { "Instantiation_inc", _wrap_Instantiation_inc, METH_O, "\n"
		"\n"
		"Operator ++.\n"
		"\n"
		""},
	 { "Instantiation_dec", _wrap_Instantiation_dec, METH_O, "\n"
		"\n"
		"Operator --.\n"
		"\n"
		""},
	 { "Instantiation_incIn", _wrap_Instantiation_incIn, METH_VARARGS, "\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Assign the first values to the tuple of the Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_setLast", _wrap_Instantiation_setLast, METH_O, "\n"
		"\n"
		"Assign the last values in the Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_setFirstIn", _wrap_Instantiation_setFirstIn, METH_VARARGS, "\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\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, NULL},
	 { "Instantiation___iadd__", _wrap_Instantiation___iadd__, METH_VARARGS, NULL},
	 { "Instantiation___isub__", _wrap_Instantiation___isub__, METH_VARARGS, NULL},
	 { "Instantiation_hamming", _wrap_Instantiation_hamming, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the hamming distance of this instantiation.\n"
		"\n"
		""},
	 { "Instantiation_reorder", _wrap_Instantiation_reorder, METH_VARARGS, "\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, NULL},
	 { "Instantiation___str__", _wrap_Instantiation___str__, METH_O, NULL},
	 { "Instantiation_setMutable", _wrap_Instantiation_setMutable, METH_O, NULL},
	 { "Instantiation_isMutable", _wrap_Instantiation_isMutable, METH_O, NULL},
	 { "Instantiation_todict", _wrap_Instantiation_todict, METH_VARARGS, "\n"
		"\n"
		"Create a dictionary `{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. Default is False\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Dict[str,int]\n"
		"    The dictionary\n"
		"\n"
		""},
	 { "Instantiation__cppfromdict", _wrap_Instantiation__cppfromdict, METH_VARARGS, NULL},
	 { "Instantiation_swigregister", Instantiation_swigregister, METH_O, NULL},
	 { "Instantiation_swiginit", Instantiation_swiginit, METH_VARARGS, NULL},
	 { "delete_GraphicalModel", _wrap_delete_GraphicalModel, METH_O, NULL},
	 { "GraphicalModel_property", _wrap_GraphicalModel_property, METH_VARARGS, "\n"
		"\n"
		"Returns the value associated to this property.\n"
		"\n"
		"Properties are a way to keep some (name,value) together with de model.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"  the name of the property\n"
		"\n"
		"Raises\n"
		"------\n"
		"NotFound\n"
		"  if no name property is found\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"  The value associated to this name\n"
		"\n"
		""},
	 { "GraphicalModel_propertyWithDefault", _wrap_GraphicalModel_propertyWithDefault, METH_VARARGS, "\n"
		"\n"
		"Returns the value associated to this property or the default value if there is no such property.\n"
		"\n"
		"Properties are a way to keep some information (name,value) together with de model.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"  the name of the property\n"
		"byDefault: str\n"
		"  the value by default if no property has been found.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"  The value associated to this name or the value by default.\n"
		"\n"
		""},
	 { "GraphicalModel_setProperty", _wrap_GraphicalModel_setProperty, METH_VARARGS, "\n"
		"\n"
		"Create or change the couple (name,value) in the properties.\n"
		"\n"
		"Properties are a way to keep some information (name,value) together with de model.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"  the name of the property\n"
		"value: str\n"
		"  the value of the property.\n"
		"\n"
		""},
	 { "GraphicalModel_properties", _wrap_GraphicalModel_properties, METH_O, NULL},
	 { "GraphicalModel_variableNodeMap", _wrap_GraphicalModel_variableNodeMap, METH_O, NULL},
	 { "GraphicalModel_size", _wrap_GraphicalModel_size, METH_O, NULL},
	 { "GraphicalModel_empty", _wrap_GraphicalModel_empty, METH_O, "\n"
		"\n"
		"Check if there are some variables in the model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if there is no variable in the model.\n"
		"\n"
		""},
	 { "GraphicalModel_exists", _wrap_GraphicalModel_exists, METH_VARARGS, "\n"
		"\n"
		"Check if a node with this name or id exists\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"norid: str|int\n"
		"  name or id of the searched node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if there is a node with such a name or id\n"
		"\n"
		""},
	 { "GraphicalModel_names", _wrap_GraphicalModel_names, METH_VARARGS, "\n"
		"\n"
		"Set of names of variables in the model\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[str]\n"
		"	The names of the graph variables\n"
		"\n"
		""},
	 { "GraphicalModel_ids", _wrap_GraphicalModel_ids, METH_VARARGS, "\n"
		"\n"
		"List of ids for a list of names of variables in the model\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lov : List[str]\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List[int]\n"
		"	The ids for the list of names of the graph variables\n"
		"\n"
		""},
	 { "GraphicalModel_nodeset", _wrap_GraphicalModel_nodeset, METH_VARARGS, "\n"
		"\n"
		"Set of ids for a list of names of variables in the model\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lov : List[str]\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"	The set of ids for the list of names of the graph variables\n"
		"\n"
		""},
	 { "GraphicalModel_variables", _wrap_GraphicalModel_variables, METH_VARARGS, NULL},
	 { "GraphicalModel_nodes", _wrap_GraphicalModel_nodes, METH_O, NULL},
	 { "GraphicalModel_completeInstantiation", _wrap_GraphicalModel_completeInstantiation, METH_O, "\n"
		"\n"
		"Give an instantiation over all the variables of the model\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Instantiation\n"
		"  a complete Instantiation for the model\n"
		"\n"
		""},
	 { "GraphicalModel_variable", _wrap_GraphicalModel_variable, METH_VARARGS, NULL},
	 { "GraphicalModel_nodeId", _wrap_GraphicalModel_nodeId, METH_VARARGS, NULL},
	 { "GraphicalModel_idFromName", _wrap_GraphicalModel_idFromName, METH_VARARGS, NULL},
	 { "GraphicalModel_variableFromName", _wrap_GraphicalModel_variableFromName, METH_VARARGS, NULL},
	 { "GraphicalModel_log10DomainSize", _wrap_GraphicalModel_log10DomainSize, METH_O, "\n"
		"\n"
		"returns the log10 of the domain size of the model defined as the product of the domain sizes of the variables in the model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the log10 domain size.\n"
		"\n"
		""},
	 { "GraphicalModel_isIndependent", _wrap_GraphicalModel_isIndependent, METH_VARARGS, "\n"
		"\n"
		"check if nodes X and nodes Y are independent given nodes Z\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"\n"
		"Raises\n"
		"------\n"
		"InvalidArgument\n"
		"  if X and Y share variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if X and Y are independent given Z in the model\n"
		"\n"
		""},
	 { "GraphicalModel_family", _wrap_GraphicalModel_family, METH_VARARGS, NULL},
	 { "GraphicalModel_swigregister", GraphicalModel_swigregister, METH_O, NULL},
	 { "delete_DAGmodel", _wrap_delete_DAGmodel, METH_O, NULL},
	 { "DAGmodel_dag", _wrap_DAGmodel_dag, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DAG\n"
		"	a constant reference to the dag of this BayesNet.\n"
		"\n"
		""},
	 { "DAGmodel_size", _wrap_DAGmodel_size, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of nodes in the graph\n"
		"\n"
		""},
	 { "DAGmodel_sizeArcs", _wrap_DAGmodel_sizeArcs, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of arcs in the graph\n"
		"\n"
		""},
	 { "DAGmodel_nodes", _wrap_DAGmodel_nodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of ids\n"
		"\n"
		""},
	 { "DAGmodel_exists", _wrap_DAGmodel_exists, METH_VARARGS, "\n"
		"\n"
		"Check if a node with this name or id exists\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"norid: str|int\n"
		"  name or id of the searched node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if there is a node with such a name or id\n"
		"\n"
		""},
	 { "DAGmodel_arcs", _wrap_DAGmodel_arcs, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	The lisf of arcs in the graph\n"
		"\n"
		""},
	 { "DAGmodel_existsArc", _wrap_DAGmodel_existsArc, METH_VARARGS, "\n"
		"\n"
		"Check if an arc exists\n"
		"\n"
		"Parameters\n"
		"---------\n"
		"tail : str|int\n"
		"  the name or id of the tail of the arc\n"
		"\n"
		"head : str|int\n"
		"  the name or the id of the head of the arc\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if `tail->head` is an arc.\n"
		"\n"
		""},
	 { "DAGmodel_parents", _wrap_DAGmodel_parents, METH_VARARGS, NULL},
	 { "DAGmodel_family", _wrap_DAGmodel_family, METH_VARARGS, "\n"
		"\n"
		"give the set of parents of a node and the node\n"
		"\n"
		"Parameters\n"
		"---------\n"
		"norid : str|int\n"
		"  the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of nodeId of the family of the node `norid`\n"
		"\n"
		""},
	 { "DAGmodel_children", _wrap_DAGmodel_children, METH_VARARGS, NULL},
	 { "DAGmodel_descendants", _wrap_DAGmodel_descendants, METH_VARARGS, "\n"
		"\n"
		"give the set of nodeid of descendants of a node\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"norid : str|int\n"
		"  the name or the id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of ids of the descendants of node `norid`.\n"
		"\n"
		""},
	 { "DAGmodel_ancestors", _wrap_DAGmodel_ancestors, METH_VARARGS, "\n"
		"\n"
		"give the set of nodeid of ancestors of a node\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"norid : str|int\n"
		"  the name or the id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of ids of the ancestors of node `norid`.\n"
		"\n"
		""},
	 { "DAGmodel_moralizedAncestralGraph", _wrap_DAGmodel_moralizedAncestralGraph, METH_VARARGS, "\n"
		"\n"
		"build a UndiGraph by moralizing the Ancestral Graph of a list of nodes\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nodes : str|int|List[str|int]\n"
		"  the list of of nodeIds or names\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"  gum.UndiGraph only knows NodeId. Hence the moralized ancestral graph does not include the names of the variables.graph\n"
		"\n"
		"Returns\n"
		"-------\n"
		"gum.UndiGraph\n"
		"  the moralized ancestral graph of the nodes\n"
		"\n"
		""},
	 { "DAGmodel_isIndependent", _wrap_DAGmodel_isIndependent, METH_VARARGS, "\n"
		"\n"
		"check if nodes X and nodes Y are independent given nodes Z\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"\n"
		"Raises\n"
		"------\n"
		"InvalidArgument\n"
		"  if X and Y share variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if X and Y are independent given Z in the model\n"
		"\n"
		""},
	 { "DAGmodel_moralGraph", _wrap_DAGmodel_moralGraph, METH_O, "\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_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"    the list of the nodes Ids in a topological order\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidDirectedCycle\n"
		"	If this graph contains cycles\n"
		"\n"
		""},
	 { "DAGmodel_hasSameStructure", _wrap_DAGmodel_hasSameStructure, METH_VARARGS, "\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_minimalCondSet", _wrap_DAGmodel_minimalCondSet, METH_VARARGS, NULL},
	 { "DAGmodel_swigregister", DAGmodel_swigregister, METH_O, NULL},
	 { "delete_UGmodel", _wrap_delete_UGmodel, METH_O, NULL},
	 { "UGmodel_graph", _wrap_UGmodel_graph, METH_O, NULL},
	 { "UGmodel_size", _wrap_UGmodel_size, METH_O, NULL},
	 { "UGmodel_sizeEdges", _wrap_UGmodel_sizeEdges, METH_O, NULL},
	 { "UGmodel_nodes", _wrap_UGmodel_nodes, METH_O, NULL},
	 { "UGmodel_exists", _wrap_UGmodel_exists, METH_VARARGS, "\n"
		"\n"
		"Check if a node with this name or id exists\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"norid: str|int\n"
		"  name or id of the searched node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if there is a node with such a name or id\n"
		"\n"
		""},
	 { "UGmodel_edges", _wrap_UGmodel_edges, METH_O, NULL},
	 { "UGmodel_existsEdge", _wrap_UGmodel_existsEdge, METH_VARARGS, NULL},
	 { "UGmodel_neighbours", _wrap_UGmodel_neighbours, METH_VARARGS, NULL},
	 { "UGmodel_isIndependent", _wrap_UGmodel_isIndependent, METH_VARARGS, "\n"
		"\n"
		"check if nodes X and nodes Y are independent given nodes Z\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"\n"
		"Raises\n"
		"------\n"
		"InvalidArgument\n"
		"  if X and Y share variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if X and Y are independent given Z in the model\n"
		"\n"
		""},
	 { "UGmodel_hasSameStructure", _wrap_UGmodel_hasSameStructure, METH_VARARGS, NULL},
	 { "UGmodel_family", _wrap_UGmodel_family, METH_VARARGS, NULL},
	 { "UGmodel_swigregister", UGmodel_swigregister, METH_O, NULL},
	 { "new_ApproximationScheme", _wrap_new_ApproximationScheme, METH_VARARGS, NULL},
	 { "delete_ApproximationScheme", _wrap_delete_ApproximationScheme, METH_O, NULL},
	 { "ApproximationScheme_setEpsilon", _wrap_ApproximationScheme_setEpsilon, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : float\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "ApproximationScheme_epsilon", _wrap_ApproximationScheme_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "ApproximationScheme_disableEpsilon", _wrap_ApproximationScheme_disableEpsilon, METH_O, "\n"
		"\n"
		"Disable epsilon as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_enableEpsilon", _wrap_ApproximationScheme_enableEpsilon, METH_O, "\n"
		"\n"
		"Enable epsilon as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_isEnabledEpsilon", _wrap_ApproximationScheme_isEnabledEpsilon, METH_O, "\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"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "ApproximationScheme_minEpsilonRate", _wrap_ApproximationScheme_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "ApproximationScheme_disableMinEpsilonRate", _wrap_ApproximationScheme_disableMinEpsilonRate, METH_O, "\n"
		"\n"
		"Disable a min epsilon rate as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_enableMinEpsilonRate", _wrap_ApproximationScheme_enableMinEpsilonRate, METH_O, "\n"
		"\n"
		"Enable a min epsilon rate as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_isEnabledMinEpsilonRate", _wrap_ApproximationScheme_isEnabledMinEpsilonRate, METH_O, "\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"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "ApproximationScheme_maxIter", _wrap_ApproximationScheme_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "ApproximationScheme_disableMaxIter", _wrap_ApproximationScheme_disableMaxIter, METH_O, "\n"
		"\n"
		"Disable max iterations as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_enableMaxIter", _wrap_ApproximationScheme_enableMaxIter, METH_O, "\n"
		"\n"
		"Enable max iterations as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_isEnabledMaxIter", _wrap_ApproximationScheme_isEnabledMaxIter, METH_O, "\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"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : float\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "ApproximationScheme_maxTime", _wrap_ApproximationScheme_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "ApproximationScheme_currentTime", _wrap_ApproximationScheme_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	get the current running time in second (float)\n"
		"\n"
		""},
	 { "ApproximationScheme_disableMaxTime", _wrap_ApproximationScheme_disableMaxTime, METH_O, "\n"
		"\n"
		"Disable max time as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_enableMaxTime", _wrap_ApproximationScheme_enableMaxTime, METH_O, "\n"
		"\n"
		"Enable max time as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_isEnabledMaxTime", _wrap_ApproximationScheme_isEnabledMaxTime, METH_O, "\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"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "ApproximationScheme_periodSize", _wrap_ApproximationScheme_periodSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "ApproximationScheme_setVerbosity", _wrap_ApproximationScheme_setVerbosity, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "ApproximationScheme_verbosity", _wrap_ApproximationScheme_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "ApproximationScheme_stateApproximationScheme", _wrap_ApproximationScheme_stateApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the state of the approximation scheme\n"
		"\n"
		""},
	 { "ApproximationScheme_nbrIterations", _wrap_ApproximationScheme_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "ApproximationScheme_history", _wrap_ApproximationScheme_history, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.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"
		"\n"
		"Initiate the approximation scheme.\n"
		"\n"
		""},
	 { "ApproximationScheme_startOfPeriod", _wrap_ApproximationScheme_startOfPeriod, METH_O, "\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"
		"\n"
		"Update the approximation scheme.\n"
		"\n"
		""},
	 { "ApproximationScheme_remainingBurnIn", _wrap_ApproximationScheme_remainingBurnIn, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of remaining burn in\n"
		"\n"
		""},
	 { "ApproximationScheme_stopApproximationScheme", _wrap_ApproximationScheme_stopApproximationScheme, METH_O, "\n"
		"\n"
		"Stop the approximation scheme.\n"
		"\n"
		""},
	 { "ApproximationScheme_continueApproximationScheme", _wrap_ApproximationScheme_continueApproximationScheme, METH_VARARGS, "\n"
		"\n"
		"Continue the approximation scheme.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"error : float\n"
		"\n"
		""},
	 { "ApproximationScheme_swigregister", ApproximationScheme_swigregister, METH_O, NULL},
	 { "ApproximationScheme_swiginit", ApproximationScheme_swiginit, METH_VARARGS, NULL},
	 { "fastVariable", _wrap_fastVariable, METH_VARARGS, "\n"
		"\n"
		"Use *fast* syntax to add a variable in the BayesNet.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotAllowed\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"fast_description: str\n"
		"  string following *fast* syntax description\n"
		"default_nbrmod: int\n"
		"  nbr of modality if fast_description does not indicate it.\n"
		"  `default_nbrmod=1` is the way to create a variable with only one value (for instance for reward in influence diagram).\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> print(gum.fastVariable('A{On|Off|Defun}'))\n"
		"A:Labelized({On|Off|Defun})\n"
		">>> print(gum.fastVariable('A{3.14|0|1.15}'))\n"
		"A:NumericalDiscrete({0|1.15|3.14})\n"
		">>> print(gum.fastVariable('A{1.2:5.2:5}}'))\n"
		"A:NumericalDiscrete({1.2|2.2|3.2|4.2|5.2})\n"
		">>> print(gum.fastVariable('A{1|3|9}'))\n"
		"A:Integer({1|3|9})\n"
		">>> print(gum.fastVariable('A[4,6]'))\n"
		"A:Range([4,6])\n"
		">>> print(gum.fastVariable('A[5]'))\n"
		"A:Range([0,4])\n"
		">>> print(gum.fastVariable('A[4,6,10]'))\n"
		"A:Discretized(<[4;6[,[6;10]>)\n"
		">>> print(gum.fastVariable('A[1:6:5]'))\n"
		"A:Discretized(<[1;2[,[2;3[,[3;4[,[4;5[,[5;6]>)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "randomDistribution", _wrap_randomDistribution, METH_O, "\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, NULL},
	 { "delete_DiscretizedVariable", _wrap_delete_DiscretizedVariable, METH_O, NULL},
	 { "DiscretizedVariable_clone", _wrap_DiscretizedVariable_clone, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiscretizedVariable\n"
		"	a copy of the DiscretizedVariable\n"
		"\n"
		""},
	 { "DiscretizedVariable_varType", _wrap_DiscretizedVariable_varType, METH_O, "\n"
		"\n"
		"returns the type of variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	the type of the variable.\n"
		"\n"
		"	0: DiscretizedVariable, 1: LabelizedVariable, 2: IntegerVariable, 3: RangeVariable, 4:\n"
		"\n"
		""},
	 { "DiscretizedVariable_isTick", _wrap_DiscretizedVariable_isTick, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"aTick : float\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"
		"\n"
		"Parameters\n"
		"----------\n"
		"aTick : float\n"
		"	the Tick to be added\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiscretizedVariable\n"
		"	the discretized variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.DefaultInLabel\n"
		"	If the Tick is already defined\n"
		"\n"
		""},
	 { "DiscretizedVariable_eraseTicks", _wrap_DiscretizedVariable_eraseTicks, METH_O, "\n"
		"\n"
		"erase all the Ticks\n"
		"\n"
		""},
	 { "DiscretizedVariable_label", _wrap_DiscretizedVariable_label, METH_VARARGS, "\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"
		"pyagrum.OutOfBounds\n"
		"	If the variable does not contain the label\n"
		"\n"
		""},
	 { "DiscretizedVariable_numerical", _wrap_DiscretizedVariable_numerical, METH_VARARGS, "\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_draw", _wrap_DiscretizedVariable_draw, METH_VARARGS, "\n"
		"\n"
		"Allow to draw a value in the i-th interval of the discretized variable.1\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : int\n"
		"	the index of the interval to draw\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float :\n"
		"	the value randomly drawn in the i-th interval\n"
		"\n"
		""},
	 { "DiscretizedVariable_index", _wrap_DiscretizedVariable_index, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of modalities in the variable domain\n"
		"\n"
		""},
	 { "DiscretizedVariable_domain", _wrap_DiscretizedVariable_domain, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    the domain of the variable as a string\n"
		"\n"
		""},
	 { "DiscretizedVariable_stype", _wrap_DiscretizedVariable_stype, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	a description of its type\n"
		"\n"
		""},
	 { "DiscretizedVariable_tick", _wrap_DiscretizedVariable_tick, METH_VARARGS, "\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 : float\n"
		"	the i-th Tick\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"	If the index is greater than the number of Ticks\n"
		"\n"
		""},
	 { "DiscretizedVariable_ticks", _wrap_DiscretizedVariable_ticks, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple :\n"
		"	a tuple containing all the Ticks\n"
		"\n"
		""},
	 { "DiscretizedVariable_closestIndex", _wrap_DiscretizedVariable_closestIndex, METH_VARARGS, "\n"
		"\n"
		"For numerical discrete variables (all except :class:`gum.LabelizedVariable`), this method returns the index of the closest value to a given float value in the variable's domain.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value : float\n"
		"  the value for which we want to find the closest index\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the index of the closest value to `value` in the variable's domain\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotImplementedYet\n"
		"  if the variable is not numerical discrete (i.e., if it is a :class:`gum.LabelizedVariable`).\n"
		"\n"
		""},
	 { "DiscretizedVariable_toFast", _wrap_DiscretizedVariable_toFast, METH_O, NULL},
	 { "DiscretizedVariable___repr__", _wrap_DiscretizedVariable___repr__, METH_O, NULL},
	 { "DiscretizedVariable___str__", _wrap_DiscretizedVariable___str__, METH_O, NULL},
	 { "DiscretizedVariable_swigregister", DiscretizedVariable_swigregister, METH_O, NULL},
	 { "DiscretizedVariable_swiginit", DiscretizedVariable_swiginit, METH_VARARGS, NULL},
	 { "delete_MultiDimContainer", _wrap_delete_MultiDimContainer, METH_O, NULL},
	 { "MultiDimContainer_set", _wrap_MultiDimContainer_set, METH_VARARGS, NULL},
	 { "MultiDimContainer_get", _wrap_MultiDimContainer_get, METH_VARARGS, NULL},
	 { "MultiDimContainer_fill", _wrap_MultiDimContainer_fill, METH_VARARGS, NULL},
	 { "MultiDimContainer_populate", _wrap_MultiDimContainer_populate, METH_VARARGS, NULL},
	 { "MultiDimContainer_copyFrom", _wrap_MultiDimContainer_copyFrom, METH_VARARGS, NULL},
	 { "MultiDimContainer_extractFrom", _wrap_MultiDimContainer_extractFrom, METH_VARARGS, NULL},
	 { "MultiDimContainer_content", _wrap_MultiDimContainer_content, METH_VARARGS, NULL},
	 { "MultiDimContainer_getMasterRef", _wrap_MultiDimContainer_getMasterRef, METH_VARARGS, NULL},
	 { "MultiDimContainer_copy", _wrap_MultiDimContainer_copy, METH_VARARGS, NULL},
	 { "MultiDimContainer_toString", _wrap_MultiDimContainer_toString, METH_VARARGS, NULL},
	 { "MultiDimContainer___eq__", _wrap_MultiDimContainer___eq__, METH_VARARGS, NULL},
	 { "MultiDimContainer___ne__", _wrap_MultiDimContainer___ne__, METH_VARARGS, NULL},
	 { "MultiDimContainer_apply", _wrap_MultiDimContainer_apply, METH_VARARGS, NULL},
	 { "MultiDimContainer_reduce", _wrap_MultiDimContainer_reduce, METH_VARARGS, NULL},
	 { "MultiDimContainer_beginMultipleChanges", _wrap_MultiDimContainer_beginMultipleChanges, METH_O, NULL},
	 { "MultiDimContainer_endMultipleChanges", _wrap_MultiDimContainer_endMultipleChanges, METH_VARARGS, NULL},
	 { "MultiDimContainer_swigregister", MultiDimContainer_swigregister, METH_O, NULL},
	 { "Tensor_deterministicTensor", _wrap_Tensor_deterministicTensor, METH_VARARGS, "\n"
		"\n"
		"This static method generates a Tensor representing a deterministic function of a :class:`pyagrum.DiscreteVariable`) such as a hard evidence.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyagrum.DiscreteVariable\n"
		"  the variable to use\n"
		"value: int | str\n"
		"  the indice or the label of the value for the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  The representation of the deterministic function as a :class:`pyagrum.Tensor`.\n"
		"\n"
		""},
	 { "Tensor_uniformTensor", _wrap_Tensor_uniformTensor, METH_O, NULL},
	 { "new_Tensor", _wrap_new_Tensor, METH_VARARGS, NULL},
	 { "delete_Tensor", _wrap_delete_Tensor, METH_O, NULL},
	 { "Tensor_random", _wrap_Tensor_random, METH_O, NULL},
	 { "Tensor_randomDistribution", _wrap_Tensor_randomDistribution, METH_O, NULL},
	 { "Tensor_randomCPT", _wrap_Tensor_randomCPT, METH_O, NULL},
	 { "Tensor_noising", _wrap_Tensor_noising, METH_VARARGS, NULL},
	 { "Tensor_isNonZeroMap", _wrap_Tensor_isNonZeroMap, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a boolean-like tensor using the predicate `isNonZero`.\n"
		"\n"
		""},
	 { "Tensor_sum", _wrap_Tensor_sum, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float :\n"
		"  the sum of all elements in the Tensor\n"
		"\n"
		""},
	 { "Tensor_product", _wrap_Tensor_product, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the product of all elements in the Tensor\n"
		"\n"
		""},
	 { "Tensor_max", _wrap_Tensor_max, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the maximum of all elements in the Tensor\n"
		"\n"
		""},
	 { "Tensor_min", _wrap_Tensor_min, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the min of all elements in the Tensor\n"
		"\n"
		""},
	 { "Tensor_maxNonOne", _wrap_Tensor_maxNonOne, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the maximum of non one elements in the Tensor\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"  If all value == 1.0\n"
		"\n"
		""},
	 { "Tensor_minNonZero", _wrap_Tensor_minNonZero, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the min of non zero elements in the Tensor\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"  If all value == 0.0\n"
		"\n"
		""},
	 { "Tensor_findAll", _wrap_Tensor_findAll, METH_VARARGS, "\n"
		"\n"
		"Find all the position of a value in the Tensor.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : float\n"
		"  the value to find\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list[dict[str,int]]\n"
		"  a list of all the instantiations (as python dictionary) where the value is found\n"
		"\n"
		""},
	 { "Tensor_entropy", _wrap_Tensor_entropy, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the entropy of the tensor\n"
		"\n"
		""},
	 { "Tensor_reorganize", _wrap_Tensor_reorganize, METH_VARARGS, "\n"
		"\n"
		"Create a new Tensor 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.Tensor\n"
		"  a reference to the modified tensor\n"
		"\n"
		""},
	 { "Tensor_putFirst", _wrap_Tensor_putFirst, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyagrum.DiscreteVariable\n"
		"    The variable for which the index should be 0.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a reference to the modified tensor\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the var is not in the tensor\n"
		"\n"
		""},
	 { "Tensor_fillWith", _wrap_Tensor_fillWith, METH_VARARGS, "\n"
		"\n"
		"Automatically fills the tensor with v.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : number or list of values or pyagrum.Tensor\n"
		"    a value or a list/pyagrum.Tensor containing the values to fill the Tensor with.\n"
		"\n"
		"mapping : list|tuple|dict\n"
		"\n"
		"Warning\n"
		"-------\n"
		"    - if `v` is a list, the size of the list must be the size of the tensor\n"
		"\n"
		"    - if `v` is a ref:pyagrum.Tensor, it must contain variables with exactly the same names and labels but not necessarily the same variables. If\n"
		"\n"
		"    - If the second argument `mapping` is given, `mapping` explains how to map the variables of the tensor source to the variables of the tensor destination.\n"
		"\n"
		"    - If `mapping` is a sequence, the order follows the same order as `destination.names`. If `mapping` is a dict, the keys are the names in the destination and the values are the names in the source.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"      a reference to the modified potentia\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.SizeError\n"
		"  If v size's does not matches the domain size.\n"
		"pyagrum.ArgumentError\n"
		"  If anything wrong with the arguments.\n"
		"\n"
		""},
	 { "Tensor_abs", _wrap_Tensor_abs, METH_O, "\n"
		"\n"
		"Apply abs on every element of the container\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"    a reference to the modified tensor.\n"
		"\n"
		""},
	 { "Tensor_sq", _wrap_Tensor_sq, METH_O, "\n"
		"\n"
		"Square all the values in the Tensor\n"
		"\n"
		""},
	 { "Tensor_log2", _wrap_Tensor_log2, METH_O, "\n"
		"\n"
		"log2 all the values in the Tensor\n"
		"\n"
		"Warning\n"
		"-------\n"
		"When the Tensor contains 0 or negative values, no exception are raised but `-inf` or `nan` values are assigned.\n"
		"\n"
		""},
	 { "Tensor_sgn", _wrap_Tensor_sgn, METH_O, NULL},
	 { "Tensor_new_abs", _wrap_Tensor_new_abs, METH_O, NULL},
	 { "Tensor_new_sq", _wrap_Tensor_new_sq, METH_O, NULL},
	 { "Tensor_new_log2", _wrap_Tensor_new_log2, METH_O, NULL},
	 { "Tensor_new_sgn", _wrap_Tensor_new_sgn, METH_O, NULL},
	 { "Tensor_normalize", _wrap_Tensor_normalize, METH_O, "\n"
		"\n"
		"Normalize the Tensor (do nothing if sum is 0)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a reference to the normalized Tensor\n"
		"\n"
		""},
	 { "Tensor_KL", _wrap_Tensor_KL, METH_VARARGS, "\n"
		"\n"
		"Check the compatibility and compute the Kullback-Leibler divergence between the tensor and.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : pyagrum.Tensor\n"
		"  the tensor 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"
		"  pyagrum.InvalidArgument\n"
		"    If p is not compatible with the tensor (dimension, variables)\n"
		"  pyagrum.FatalError\n"
		"    If a zero is found in p or the tensor and not in the other.\n"
		"\n"
		""},
	 { "Tensor_normalizeAsCPT", _wrap_Tensor_normalizeAsCPT, METH_VARARGS, "\n"
		"\n"
		"Normalize the Tensor as a CPT\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a reference to the normalized Tensor\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.FatalError\n"
		"  If some distribution sums to 0\n"
		"\n"
		""},
	 { "Tensor_scale", _wrap_Tensor_scale, METH_VARARGS, "\n"
		"\n"
		"Create a new tensor multiplied by v.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : float\n"
		"  a multiplier\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  a reference to the modified tensor\n"
		"\n"
		""},
	 { "Tensor_translate", _wrap_Tensor_translate, METH_VARARGS, "\n"
		"\n"
		"Create a new tensor added with v.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : float\n"
		"  The value to be added\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  a reference to the modified tensor\n"
		"\n"
		""},
	 { "Tensor_inverse", _wrap_Tensor_inverse, METH_O, NULL},
	 { "Tensor_draw", _wrap_Tensor_draw, METH_O, "\n"
		"\n"
		"draw a value using the tensor as a probability table.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the index of the drawn value\n"
		"\n"
		""},
	 { "Tensor_memoryFootprint", _wrap_Tensor_memoryFootprint, METH_O, "\n"
		"\n"
		"get the size (in byte) of the Tensor representation in memory\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the size in byte of the representation of the Tensor in memory.\n"
		"\n"
		""},
	 { "Tensor___add__", _wrap_Tensor___add__, METH_VARARGS, NULL},
	 { "Tensor___sub__", _wrap_Tensor___sub__, METH_VARARGS, NULL},
	 { "Tensor___mul__", _wrap_Tensor___mul__, METH_VARARGS, NULL},
	 { "Tensor___truediv__", _wrap_Tensor___truediv__, METH_VARARGS, NULL},
	 { "Tensor___iadd__", _wrap_Tensor___iadd__, METH_VARARGS, NULL},
	 { "Tensor___imul__", _wrap_Tensor___imul__, METH_VARARGS, NULL},
	 { "Tensor___isub__", _wrap_Tensor___isub__, METH_VARARGS, NULL},
	 { "Tensor___itruediv__", _wrap_Tensor___itruediv__, METH_VARARGS, NULL},
	 { "Tensor_isEvidence", _wrap_Tensor_isEvidence, METH_O, NULL},
	 { "Tensor___or__", _wrap_Tensor___or__, METH_VARARGS, NULL},
	 { "Tensor___and__", _wrap_Tensor___and__, METH_VARARGS, NULL},
	 { "Tensor___invert__", _wrap_Tensor___invert__, METH_O, NULL},
	 { "Tensor_evEq", _wrap_Tensor_evEq, METH_VARARGS, "\n"
		"\n"
		"This static method generates a Tensor representing an observation where a quasi-continuous variable\n"
		"(a :class:`pyagrum.DiscretizedVariable` with many ticks) takes a specific given value.\n"
		"\n"
		"Note\n"
		"----\n"
		"  - see also :meth:`BayesNet.evEq`\n"
		"  - see also :meth:`Tensor.evGt`, :meth:`Tensor.evLt`, :meth:`Tensor.evIn`\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> A=gum.fastVariable('A[0:10:20]')\n"
		">>> p=gum.Tensor.evEq(A,5)\n"
		">>> p\n"
		"(pyagrum.Tensor@000001D7FAB06AD0)\n"
		"  A                                                                                                                                                                                                    |\n"
		"[0;0.5[  |[0.5;1[  |[1;1.5[  |[1.5;2[  |[2;2.5[  |[2.5;3[  |[3;3.5[  |[3.5;4[  |[4;4.5[  |[4.5;5[  |[5;5.5[  |[5.5;6[  |[6;6.5[  |[6.5;7[  |[7;7.5[  |[7.5;8[  |[8;8.5[  |[8.5;9[  |[9;9.5[  |[9.5;10] |\n"
		"---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|\n"
		" 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 1.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  |\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyagrum.DiscretizedVariable\n"
		"  the variable to use\n"
		"value: float\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  The representation of the evidence as a :class:`~pyagrum.Tensor`.\n"
		"\n"
		""},
	 { "Tensor_evIn", _wrap_Tensor_evIn, METH_VARARGS, "\n"
		"\n"
		"This static method generates a Tensor representing an observation where a quasi-continuous variable\n"
		"(a :class:`pyagrum.DiscretizedVariable` with many ticks) takes a value between the 2 paramerts (min,max)\n"
		"\n"
		"Note\n"
		"----\n"
		"  - see also :meth:`BayesNet.evIn`\n"
		"  - see also :meth:`Tensor.evEq`, :meth:`Tensor.evLt`, :meth:`Tensor.evGt`\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyagrum.DiscretizedVariable\n"
		"  the variable to use\n"
		"valueMin: float\n"
		"  the minimum value\n"
		"valueMax: float\n"
		"  the maximum value\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Tensor\n"
		"  The representation of the evidence as a :class:`~pyagrum.Tensor`.\n"
		"\n"
		""},
	 { "Tensor_evGt", _wrap_Tensor_evGt, METH_VARARGS, "\n"
		"\n"
		"This static method generates a Tensor representing an observation where a quasi-continuous variable\n"
		"(a :class:`pyagrum.DiscretizedVariable` with many ticks) takes a value greater than the parameter.\n"
		"\n"
		"Note\n"
		"----\n"
		"  - see also :meth:`BayesNet.evGt`\n"
		"  - see also :meth:`Tensor.evEq`, :meth:`Tensor.evLt`, :meth:`Tensor.evIn`\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> A=gum.fastVariable('A[0:10:20]')\n"
		">>> p=gum.Tensor.evGt(A,5)\n"
		">>> p\n"
		"(pyagrum.Tensor@000001D7FAB06AD0)\n"
		"  A                                                                                                                                                                                                    |\n"
		"[0;0.5[  |[0.5;1[  |[1;1.5[  |[1.5;2[  |[2;2.5[  |[2.5;3[  |[3;3.5[  |[3.5;4[  |[4;4.5[  |[4.5;5[  |[5;5.5[  |[5.5;6[  |[6;6.5[  |[6.5;7[  |[7;7.5[  |[7.5;8[  |[8;8.5[  |[8.5;9[  |[9;9.5[  |[9.5;10] |\n"
		"---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|\n"
		" 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 1.0000  | 1.0000  | 1.0000  | 1.0000  | 1.0000  | 1.0000  | 1.0000  | 1.0000  | 1.0000  | 1.0000  |\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyagrum.DiscretizedVariable\n"
		"  the variable to use\n"
		"value: float\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  The representation of the evidence as a :class:`~pyagrum.Tensor`.\n"
		"\n"
		""},
	 { "Tensor_evLt", _wrap_Tensor_evLt, METH_VARARGS, "\n"
		"\n"
		"This static method generates a Tensor representing an observation where a quasi-continuous variable\n"
		"(a :class:`pyagrum.DiscretizedVariable` with many ticks) takes a value less than the parameter.\n"
		"\n"
		"Note\n"
		"----\n"
		"  - see also :meth:`BayesNet.evLt`\n"
		"  - see also :meth:`Tensor.evEq`, :meth:`Tensor.evGt`, :meth:`Tensor.evIn`\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyagrum.DiscretizedVariable\n"
		"  the variable to use\n"
		"value: float\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  The representation of the evidence as a :class:`~pyagrum.Tensor`.\n"
		"\n"
		""},
	 { "Tensor___repr__", _wrap_Tensor___repr__, METH_O, NULL},
	 { "Tensor___str__", _wrap_Tensor___str__, METH_O, NULL},
	 { "Tensor_expectedValue", _wrap_Tensor_expectedValue, METH_VARARGS, "\n"
		"\n"
		"Calculate the mathematical expected value of a (joint) random variable using the given function as an argument.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"func : function(Dict[str,int])->float\n"
		"    A function that takes a single argument, representing the value of a python representation of a `gum.Instantiation` (as a dictionary), and returns a float.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"The `pyagrum.Tensor` is assumed to contain a joint distribution.\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> def log2cptA(x):\n"
		"...   return -math.log2(bn.cpt('A')[x])\n"
		">>> entropy_of_A=bn.cpt('A').expectedValue(log2cptA) # OK it A has no parents.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    The mathematical expected value of the random variable calculated using the given function as an argument.\n"
		"\n"
		""},
	 { "Tensor_extract", _wrap_Tensor_extract, METH_VARARGS, "\n"
		"\n"
		"create a new Tensor extracted from self given a partial instantiation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"inst : pyagrum.instantiation\n"
		"  a partial instantiation\n"
		"dict : Dict[str,str|int]\n"
		"  a dictionnary containing values for some discrete variables.\n"
		"\n"
		"Warning\n"
		"--------\n"
		"    if the dictionnary contains a key that is not the name of a variable in the `pyagrum.Tensor`,\n"
		"    this key is just not used without notification. Then `pyagrum.Tensor.extract` concerns\n"
		"    only the variables that  both are in the Tensor and in the dictionnary.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  the new Tensor\n"
		"\n"
		""},
	 { "Tensor_sumOut", _wrap_Tensor_sumOut, METH_VARARGS, "\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.Tensor\n"
		"  the projected Tensor\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If varnames contains only one variable that does not exist in the Tensor\n"
		"\n"
		""},
	 { "Tensor_prodOut", _wrap_Tensor_prodOut, METH_VARARGS, "\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.Tensor\n"
		"  the projected Tensor\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If varnames contains only one variable that does not exist in the Tensor\n"
		"\n"
		""},
	 { "Tensor_maxOut", _wrap_Tensor_maxOut, METH_VARARGS, "\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.Tensor\n"
		"  the projected Tensor\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If varnames contains only one variable that does not exist in the Tensor\n"
		"\n"
		""},
	 { "Tensor_minOut", _wrap_Tensor_minOut, METH_VARARGS, "\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.Tensor\n"
		"  the projected Tensor\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"InvalidArgument raised if varnames contains only one variable that does not exist in the Tensor\n"
		"\n"
		""},
	 { "Tensor_sumIn", _wrap_Tensor_sumIn, METH_VARARGS, "\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.Tensor\n"
		"  the projected Tensor\n"
		"\n"
		""},
	 { "Tensor_prodIn", _wrap_Tensor_prodIn, METH_VARARGS, "\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.Tensor\n"
		"  the projected Tensor\n"
		"\n"
		""},
	 { "Tensor_maxIn", _wrap_Tensor_maxIn, METH_VARARGS, "\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.Tensor\n"
		"  the projected Tensor\n"
		"\n"
		""},
	 { "Tensor_minIn", _wrap_Tensor_minIn, METH_VARARGS, "\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.Tensor\n"
		"  the projected Tensor\n"
		"\n"
		""},
	 { "Tensor_argmin", _wrap_Tensor_argmin, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tuple[Dict[str,int],float]\n"
		"  the list of positions of the min and the min of all elements in the Tensor\n"
		"\n"
		""},
	 { "Tensor_argmax", _wrap_Tensor_argmax, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tuple[Dict[str,int],float]\n"
		"  the list of positions of the max and the max of all elements in the Tensor\n"
		"\n"
		""},
	 { "Tensor___eq__", _wrap_Tensor___eq__, METH_VARARGS, NULL},
	 { "Tensor___ne__", _wrap_Tensor___ne__, METH_VARARGS, NULL},
	 { "Tensor_get", _wrap_Tensor_get, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyagrum.Instantiation\n"
		"  an Instantiation\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the value in the Tensor at the position given by the instantiation\n"
		"\n"
		""},
	 { "Tensor_set", _wrap_Tensor_set, METH_VARARGS, "\n"
		"\n"
		"Change the value pointed by i\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyagrum.Instantiation\n"
		"  The Instantiation to be changed\n"
		"value : float\n"
		"  The new value of the Instantiation\n"
		"\n"
		""},
	 { "Tensor_empty", _wrap_Tensor_empty, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    Returns true if no variable is in the tensor.\n"
		"\n"
		""},
	 { "Tensor_pos", _wrap_Tensor_pos, METH_VARARGS, "\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"
		"pyagrum.NotFound\n"
		"  If v is not in this multidimensional matrix.\n"
		"\n"
		""},
	 { "Tensor_contains", _wrap_Tensor_contains, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyagrum.Tensor\n"
		"    a DiscreteVariable.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the var is in the tensor\n"
		"\n"
		""},
	 { "Tensor_variable", _wrap_Tensor_variable, METH_VARARGS, "\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"
		"pyagrum.NotFound\n"
		"  If i does not reference a variable in this multidimensional matrix.\n"
		"\n"
		""},
	 { "Tensor_remove", _wrap_Tensor_remove, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyagrum.DiscreteVariable\n"
		"    The variable to be removed\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a reference to the modified tensor\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"IndexError raised if the var is not in the tensor\n"
		"\n"
		""},
	 { "Tensor_add", _wrap_Tensor_add, METH_VARARGS, "\n"
		"\n"
		"Add a discrete variable to the tensor.\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 Tensor.\n"
		"InvalidArgument\n"
		"  If the variable is empty.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"    a reference to the modified tensor.\n"
		"\n"
		""},
	 { "Tensor_domainSize", _wrap_Tensor_domainSize, METH_O, "\n"
		"\n"
		"Compute the size of the domain of the Tensor, i.e., the product of the domain sizes of the variables in the Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the size of the domain of the Tensor (the number of values it can take) \n"
		"\n"
		""},
	 { "Tensor_nbrDim", _wrap_Tensor_nbrDim, METH_VARARGS, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of vars in the multidimensional container.\n"
		"\n"
		""},
	 { "Tensor_swigregister", Tensor_swigregister, METH_O, NULL},
	 { "Tensor_swiginit", Tensor_swiginit, METH_VARARGS, NULL},
	 { "new_PairMPE", _wrap_new_PairMPE, METH_VARARGS, NULL},
	 { "PairMPE_first_set", _wrap_PairMPE_first_set, METH_VARARGS, NULL},
	 { "PairMPE_first_get", _wrap_PairMPE_first_get, METH_O, NULL},
	 { "PairMPE_second_set", _wrap_PairMPE_second_set, METH_VARARGS, NULL},
	 { "PairMPE_second_get", _wrap_PairMPE_second_get, METH_O, NULL},
	 { "delete_PairMPE", _wrap_delete_PairMPE, METH_O, NULL},
	 { "PairMPE_swigregister", PairMPE_swigregister, METH_O, NULL},
	 { "PairMPE_swiginit", PairMPE_swiginit, METH_VARARGS, NULL},
	 { "statsObj", _wrap_statsObj, METH_NOARGS, NULL},
	 { "getNumberOfThreads", _wrap_getNumberOfThreads, METH_NOARGS, NULL},
	 { "getMaxNumberOfThreads", _wrap_getMaxNumberOfThreads, METH_NOARGS, NULL},
	 { "getNumberOfLogicalProcessors", _wrap_getNumberOfLogicalProcessors, METH_NOARGS, NULL},
	 { "new_PythonBNListener", _wrap_new_PythonBNListener, METH_VARARGS, "\n"
		"\n"
		"Listener for Bayesian Network's modifications. This listener is notified when the structure of the BN is changed.\n"
		"\n"
		"PythonBNListener(bn:gum.BayesNet,vnm:gum.VariableNodeMap) -> PythonBNListener\n"
		"    default constructor\n"
		"\n"
		"Note\n"
		"----\n"
		"    This class est mainly automatically instantiated using the method gum.BayesNet.addStructureListener.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"bn : BaysNet\n"
		"    The bayes net to listen to\n"
		"vnm : VarNodeMap\n"
		"    A translation unit between id of node and name of variable (usually : bn.variableNodeMap()).\n"
		"\n"
		""},
	 { "delete_PythonBNListener", _wrap_delete_PythonBNListener, METH_O, NULL},
	 { "PythonBNListener_whenNodeAdded", _wrap_PythonBNListener_whenNodeAdded, METH_VARARGS, NULL},
	 { "PythonBNListener_whenNodeDeleted", _wrap_PythonBNListener_whenNodeDeleted, METH_VARARGS, NULL},
	 { "PythonBNListener_whenArcAdded", _wrap_PythonBNListener_whenArcAdded, METH_VARARGS, NULL},
	 { "PythonBNListener_whenArcDeleted", _wrap_PythonBNListener_whenArcDeleted, METH_VARARGS, NULL},
	 { "PythonBNListener_setWhenArcAdded", _wrap_PythonBNListener_setWhenArcAdded, METH_VARARGS, "\n"
		"\n"
		"Add the listener in parameter to the list of existing ones for adding an arc.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pyfunc : lambda expression\n"
		"    a function (i:int,j:int) called when when an arc (i,j) is added\n"
		"\n"
		""},
	 { "PythonBNListener_setWhenArcDeleted", _wrap_PythonBNListener_setWhenArcDeleted, METH_VARARGS, "\n"
		"\n"
		"Add the listener in parameter to the list of existing ones for deleting an arc.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pyfunc : lambda expression\n"
		"    a function (i:int,j:int) called when when an arc (i,j) is removed\n"
		"\n"
		""},
	 { "PythonBNListener_setWhenNodeAdded", _wrap_PythonBNListener_setWhenNodeAdded, METH_VARARGS, "\n"
		"\n"
		"Add the listener in parameter to the list of existing ones for adding a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pyfunc : lambda expression\n"
		"    a function (i:int,s:str) called when a node of id i and name s is added.\n"
		"\n"
		""},
	 { "PythonBNListener_setWhenNodeDeleted", _wrap_PythonBNListener_setWhenNodeDeleted, METH_VARARGS, "\n"
		"\n"
		"Add the listener in parameter to the list of existing ones for deleting an arc.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pyfunc : lambda expression\n"
		"    a function (i:int) called when a node of id i and name s is removed.\n"
		"\n"
		""},
	 { "PythonBNListener_swigregister", PythonBNListener_swigregister, METH_O, NULL},
	 { "PythonBNListener_swiginit", PythonBNListener_swiginit, METH_VARARGS, NULL},
	 { "PythonLoadListener_whenLoading", _wrap_PythonLoadListener_whenLoading, METH_VARARGS, NULL},
	 { "PythonLoadListener_setPythonListener", _wrap_PythonLoadListener_setPythonListener, METH_VARARGS, "\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "new_PythonLoadListener", _wrap_new_PythonLoadListener, METH_NOARGS, NULL},
	 { "delete_PythonLoadListener", _wrap_delete_PythonLoadListener, METH_O, NULL},
	 { "PythonLoadListener_swigregister", PythonLoadListener_swigregister, METH_O, NULL},
	 { "PythonLoadListener_swiginit", PythonLoadListener_swiginit, METH_VARARGS, NULL},
	 { "_fillLoadListeners_", _wrap__fillLoadListeners_, METH_VARARGS, NULL},
	 { "new_PythonApproximationListener", _wrap_new_PythonApproximationListener, METH_O, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"algo : IApproximationSchemeConfiguration\n"
		"	an approxmation scheme\n"
		"\n"
		""},
	 { "delete_PythonApproximationListener", _wrap_delete_PythonApproximationListener, METH_O, NULL},
	 { "PythonApproximationListener_whenProgress", _wrap_PythonApproximationListener_whenProgress, METH_VARARGS, NULL},
	 { "PythonApproximationListener_whenStop", _wrap_PythonApproximationListener_whenStop, METH_VARARGS, NULL},
	 { "PythonApproximationListener_setWhenProgress", _wrap_PythonApproximationListener_setWhenProgress, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pyfunc\n"
		"	the function to execute\n"
		"\n"
		""},
	 { "PythonApproximationListener_setWhenStop", _wrap_PythonApproximationListener_setWhenStop, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pyfunc\n"
		"	the function to execute\n"
		"\n"
		""},
	 { "PythonApproximationListener_swigregister", PythonApproximationListener_swigregister, METH_O, NULL},
	 { "PythonApproximationListener_swiginit", PythonApproximationListener_swiginit, METH_VARARGS, NULL},
	 { "new_PythonDatabaseGeneratorListener", _wrap_new_PythonDatabaseGeneratorListener, METH_O, NULL},
	 { "delete_PythonDatabaseGeneratorListener", _wrap_delete_PythonDatabaseGeneratorListener, METH_O, NULL},
	 { "PythonDatabaseGeneratorListener_whenProgress", _wrap_PythonDatabaseGeneratorListener_whenProgress, METH_VARARGS, NULL},
	 { "PythonDatabaseGeneratorListener_whenStop", _wrap_PythonDatabaseGeneratorListener_whenStop, METH_VARARGS, NULL},
	 { "PythonDatabaseGeneratorListener_setWhenProgress", _wrap_PythonDatabaseGeneratorListener_setWhenProgress, METH_VARARGS, NULL},
	 { "PythonDatabaseGeneratorListener_setWhenStop", _wrap_PythonDatabaseGeneratorListener_setWhenStop, METH_VARARGS, NULL},
	 { "PythonDatabaseGeneratorListener_swigregister", PythonDatabaseGeneratorListener_swigregister, METH_O, NULL},
	 { "PythonDatabaseGeneratorListener_swiginit", PythonDatabaseGeneratorListener_swiginit, METH_VARARGS, NULL},
	 { "BNGenerator_generate", _wrap_BNGenerator_generate, METH_VARARGS, "\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"
		"  pyagrum.OperationNotAllowed\n"
		"	If n_modmax < 2\n"
		"  pyagrum.OperationNotAllowed\n"
		"	If n_arcs is incompatible with n_nodes (not enough arcs)\n"
		"\n"
		""},
	 { "new_BNGenerator", _wrap_new_BNGenerator, METH_NOARGS, "\n"
		"\n"
		"BNGenerator is used to easily generate Bayesian networks.\n"
		"\n"
		"BNGenerator() -> BNGenerator\n"
		"    default constructor\n"
		"\n"
		""},
	 { "delete_BNGenerator", _wrap_delete_BNGenerator, METH_O, NULL},
	 { "BNGenerator_swigregister", BNGenerator_swigregister, METH_O, NULL},
	 { "BNGenerator_swiginit", BNGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_InformationTheory", _wrap_new_InformationTheory, METH_VARARGS, "\n"
		"\n"
		"This class gathers information theory concepts for subsets named X,Y and Z computed with only one (optimized) inference.\n"
		"\n"
		"\n"
		"**it=gum.InformationTheory(ie,X,Y,Z)**\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"    ie : InferenceEngine\n"
		"      the inference algorithme to use (for instance, `pyagrum.LazyPropagation`)\n"
		"    X : int or str or iterable[int or str]\n"
		"      a first nodeset\n"
		"    Y  : int or str or iterable[int or str]\n"
		"      a second nodeset\n"
		"    Z :  : int or str or iterable[int or str] (optional)\n"
		"      a third (an optional) nodeset\n"
		"\n"
		"Example\n"
		"-------\n"
		"\n"
		"      .. code:: python\n"
		"\n"
		"          import pyagrum as gum\n"
		"          bn=gum.fastBN('A->B<-C<-D->E<-F->G->A')\n"
		"          ie=gum.LazyPropagation(bn)\n"
		"          it=gum.InformationTheory(ie,'A',['B','G'],['C'])\n"
		"          print(f'Entropy(A)={it.entropyX()}'')\n"
		"          print(f'MutualInformation(A;B,G)={it.mutualInformationXY()}')\n"
		"          print(f'MutualInformation(A;B,G| C)={it.mutualInformationXYgivenZ()}')\n"
		"          print(f'VariationOfInformation(A;B,G)={it.variationOfInformationXY()}')\n"
		"\n"
		""},
	 { "InformationTheory_entropyXY", _wrap_InformationTheory_entropyXY, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  float\n"
		"    The entropy of nodeset, union of X and Y.\n"
		"\n"
		""},
	 { "InformationTheory_entropyX", _wrap_InformationTheory_entropyX, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  The entropy of nodeset X.\n"
		"\n"
		""},
	 { "InformationTheory_entropyY", _wrap_InformationTheory_entropyY, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  float\n"
		"    The entropy of nodeset X.\n"
		"\n"
		""},
	 { "InformationTheory_entropyXgivenY", _wrap_InformationTheory_entropyXgivenY, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  float\n"
		"    The conditional entropy of nodeset X conditionned by nodeset Y\n"
		"\n"
		""},
	 { "InformationTheory_entropyYgivenX", _wrap_InformationTheory_entropyYgivenX, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  float\n"
		"    The conditional entropy of nodeset Y conditionned by nodeset X\n"
		"\n"
		""},
	 { "InformationTheory_mutualInformationXY", _wrap_InformationTheory_mutualInformationXY, METH_O, NULL},
	 { "InformationTheory_variationOfInformationXY", _wrap_InformationTheory_variationOfInformationXY, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  float\n"
		"    The variation of information between nodeset X and nodeset Y\n"
		"\n"
		""},
	 { "InformationTheory_entropyXYgivenZ", _wrap_InformationTheory_entropyXYgivenZ, METH_O, NULL},
	 { "InformationTheory_mutualInformationXYgivenZ", _wrap_InformationTheory_mutualInformationXYgivenZ, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  float\n"
		"    The conditional mutual information between nodeset X and nodeset Y conditionned by nodeset Z\n"
		"\n"
		""},
	 { "delete_InformationTheory", _wrap_delete_InformationTheory, METH_O, NULL},
	 { "InformationTheory_swigregister", InformationTheory_swigregister, METH_O, NULL},
	 { "InformationTheory_swiginit", InformationTheory_swiginit, METH_VARARGS, NULL},
	 { "new_PRMexplorer", _wrap_new_PRMexplorer, METH_NOARGS, "\n"
		"\n"
		"PRMexplorer helps navigate through probabilistic relational models.\n"
		"\n"
		"PRMexplorer() -> PRMexplorer\n"
		"    default constructor\n"
		"\n"
		""},
	 { "delete_PRMexplorer", _wrap_delete_PRMexplorer, METH_O, NULL},
	 { "PRMexplorer_load", _wrap_PRMexplorer_load, METH_VARARGS, "\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"
		"pyagrum.FatalError\n"
		"	If file not found\n"
		"\n"
		""},
	 { "PRMexplorer_isType", _wrap_PRMexplorer_isType, METH_VARARGS, "\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"
		"\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"
		"\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"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of classes\n"
		"\n"
		""},
	 { "PRMexplorer_classAttributes", _wrap_PRMexplorer_classAttributes, METH_VARARGS, "\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"
		"  pyagrum.IndexError\n"
		"	If the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_isAttribute", _wrap_PRMexplorer_isAttribute, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the class is not in the PRM\n"
		"pyagrum.IndexError\n"
		"	If att_name is not an element of class_name\n"
		"\n"
		""},
	 { "PRMexplorer_classReferences", _wrap_PRMexplorer_classReferences, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_classParameters", _wrap_PRMexplorer_classParameters, METH_VARARGS, "\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"
		"  pyagrum.IndexError\n"
		"	If the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_classImplements", _wrap_PRMexplorer_classImplements, METH_VARARGS, "\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"
		"\n"
		"min/max/count/exists/forall/or/and/amplitude/median\n"
		"\n"
		""},
	 { "PRMexplorer_aggType_get", _wrap_PRMexplorer_aggType_get, METH_O, "\n"
		"\n"
		"min/max/count/exists/forall/or/and/amplitude/median\n"
		"\n"
		""},
	 { "PRMexplorer_classAggregates", _wrap_PRMexplorer_classAggregates, METH_VARARGS, "\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"
		"  pyagrum.IndexError\n"
		"	If the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_classSlotChains", _wrap_PRMexplorer_classSlotChains, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	if the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_classDag", _wrap_PRMexplorer_classDag, METH_VARARGS, "\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"
		"  pyagrum.IndexError\n"
		"	If the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getalltheSystems", _wrap_PRMexplorer_getalltheSystems, METH_O, "\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"
		"\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"
		"pyagrum.IndexError\n"
		"	If the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getDirectSubClass", _wrap_PRMexplorer_getDirectSubClass, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_cpf", _wrap_PRMexplorer_cpf, METH_VARARGS, "\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.Tensor\n"
		"	the tensor of the attribute\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If the class element doesn't have any gum::Tensor (like a gum::PRMReferenceSlot).\n"
		"pyagrum.IndexError\n"
		"	If the class is not in the PRM\n"
		"pyagrum.IndexError\n"
		"	If the attribute in parameters does not exist\n"
		"\n"
		""},
	 { "PRMexplorer_types", _wrap_PRMexplorer_types, METH_O, "\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"
		"\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"
		"pyagrum.IndexError\n"
		"	If the type is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getDirectSubTypes", _wrap_PRMexplorer_getDirectSubTypes, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the type is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getLabels", _wrap_PRMexplorer_getLabels, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the type is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getLabelMap", _wrap_PRMexplorer_getLabelMap, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the type is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_interfaces", _wrap_PRMexplorer_interfaces, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of interfaces in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_interAttributes", _wrap_PRMexplorer_interAttributes, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the type is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_interReferences", _wrap_PRMexplorer_interReferences, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the type is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getSuperInterface", _wrap_PRMexplorer_getSuperInterface, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the interface is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getDirectSubInterfaces", _wrap_PRMexplorer_getDirectSubInterfaces, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the interface is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getImplementations", _wrap_PRMexplorer_getImplementations, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the interface is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_swigregister", PRMexplorer_swigregister, METH_O, NULL},
	 { "PRMexplorer_swiginit", PRMexplorer_swiginit, METH_VARARGS, NULL},
	 { "new_EssentialGraph", _wrap_new_EssentialGraph, METH_VARARGS, NULL},
	 { "delete_EssentialGraph", _wrap_delete_EssentialGraph, METH_O, NULL},
	 { "EssentialGraph_pdag", _wrap_EssentialGraph_pdag, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.PDAG\n"
		"	the PDAG (Partially Directed Graph)\n"
		"\n"
		""},
	 { "EssentialGraph_toDot", _wrap_EssentialGraph_toDot, METH_O, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of arcs in the graph\n"
		"\n"
		""},
	 { "EssentialGraph_sizeEdges", _wrap_EssentialGraph_sizeEdges, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of edges in the graph\n"
		"\n"
		""},
	 { "EssentialGraph_sizeNodes", _wrap_EssentialGraph_sizeNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of nodes in the graph\n"
		"\n"
		""},
	 { "EssentialGraph_size", _wrap_EssentialGraph_size, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of nodes in the graph\n"
		"\n"
		""},
	 { "EssentialGraph_skeleton", _wrap_EssentialGraph_skeleton, METH_O, NULL},
	 { "EssentialGraph_idFromName", _wrap_EssentialGraph_idFromName, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"  the name of the variable in the model\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the nodeId from the name of the variable in the model\n"
		"\n"
		""},
	 { "EssentialGraph_nameFromId", _wrap_EssentialGraph_nameFromId, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node : int\n"
		"  the nodeId of the variable in the model\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"  the name of the variable in the model from the nodeId\n"
		"\n"
		""},
	 { "EssentialGraph_nodes", _wrap_EssentialGraph_nodes, METH_O, NULL},
	 { "EssentialGraph_arcs", _wrap_EssentialGraph_arcs, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	The lisf of arcs in the EssentialGraph\n"
		"\n"
		""},
	 { "EssentialGraph_parents", _wrap_EssentialGraph_parents, METH_VARARGS, "\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"
		"\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"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"  the list of the edges\n"
		"\n"
		""},
	 { "EssentialGraph_neighbours", _wrap_EssentialGraph_neighbours, METH_VARARGS, "\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_O, NULL},
	 { "EssentialGraph_swiginit", EssentialGraph_swiginit, METH_VARARGS, NULL},
	 { "new_MarkovBlanket", _wrap_new_MarkovBlanket, METH_VARARGS, NULL},
	 { "delete_MarkovBlanket", _wrap_delete_MarkovBlanket, METH_O, NULL},
	 { "MarkovBlanket_dag", _wrap_MarkovBlanket_dag, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DAG\n"
		"  a copy of the DAG\n"
		"\n"
		""},
	 { "MarkovBlanket_toDot", _wrap_MarkovBlanket_toDot, METH_O, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of arcs in the graph\n"
		"\n"
		""},
	 { "MarkovBlanket_sizeNodes", _wrap_MarkovBlanket_sizeNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of nodes in the graph\n"
		"\n"
		""},
	 { "MarkovBlanket_size", _wrap_MarkovBlanket_size, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of nodes in the graph\n"
		"\n"
		""},
	 { "MarkovBlanket_hasSameStructure", _wrap_MarkovBlanket_hasSameStructure, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of ids\n"
		"\n"
		""},
	 { "MarkovBlanket_arcs", _wrap_MarkovBlanket_arcs, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"	the list of the arcs\n"
		"\n"
		""},
	 { "MarkovBlanket_parents", _wrap_MarkovBlanket_parents, METH_VARARGS, "\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"
		"\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_O, NULL},
	 { "MarkovBlanket_swiginit", MarkovBlanket_swiginit, METH_VARARGS, NULL},
	 { "new_StructuralComparator", _wrap_new_StructuralComparator, METH_NOARGS, NULL},
	 { "delete_StructuralComparator", _wrap_delete_StructuralComparator, METH_O, NULL},
	 { "StructuralComparator_compare", _wrap_StructuralComparator_compare, METH_VARARGS, "\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"
		"\n"
		"Rate of true postive over labelized edges.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the precision of the tested graph skeleton\n"
		"\n"
		""},
	 { "StructuralComparator_recall_skeleton", _wrap_StructuralComparator_recall_skeleton, METH_O, "\n"
		"\n"
		"Rate of true postive over labelized edges.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the recall of the tested graph skeleton\n"
		"\n"
		""},
	 { "StructuralComparator_f_score_skeleton", _wrap_StructuralComparator_f_score_skeleton, METH_O, "\n"
		"\n"
		"Harmonic mean between recall and precision.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the tarmonic mean of the tested graph skeleton\n"
		"\n"
		""},
	 { "StructuralComparator_precision", _wrap_StructuralComparator_precision, METH_O, "\n"
		"\n"
		"Rate of true postive over postively labelized arcs/edges.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the precision of the tested graph\n"
		"\n"
		""},
	 { "StructuralComparator_recall", _wrap_StructuralComparator_recall, METH_O, "\n"
		"\n"
		"Rate of true postive over labelized arcs/edges.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the recall of the tested graph\n"
		"\n"
		""},
	 { "StructuralComparator_f_score", _wrap_StructuralComparator_f_score, METH_O, "\n"
		"\n"
		"Harmonic mean between recall and precision.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the harmonic mean of the tested graph\n"
		"\n"
		""},
	 { "StructuralComparator_swigregister", StructuralComparator_swigregister, METH_O, NULL},
	 { "StructuralComparator_swiginit", StructuralComparator_swiginit, METH_VARARGS, NULL},
	 { "delete_IBayesNet", _wrap_delete_IBayesNet, METH_O, NULL},
	 { "IBayesNet_cpt", _wrap_IBayesNet_cpt, METH_VARARGS, "\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.Tensor\n"
		"	The variable's CPT.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"	If no variable's id matches varId.\n"
		"\n"
		""},
	 { "IBayesNet_variableNodeMap", _wrap_IBayesNet_variableNodeMap, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.variableNodeMap\n"
		"	the variable node map\n"
		"\n"
		""},
	 { "IBayesNet_variable", _wrap_IBayesNet_variable, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "IBayesNet_nodeId", _wrap_IBayesNet_nodeId, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "IBayesNet_idFromName", _wrap_IBayesNet_idFromName, METH_VARARGS, "\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"
		"Notes\n"
		"-----\n"
		"  A convenient shortcut for `g.variableFromName(name)` is `g[name]`.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	The variable's node id.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"	If name does not match a variable in the graph\n"
		"\n"
		""},
	 { "IBayesNet_variableFromName", _wrap_IBayesNet_variableFromName, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "IBayesNet_jointProbability", _wrap_IBayesNet_jointProbability, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyagrum.instantiation\n"
		"	an instantiation of the variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\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"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyagrum.instantiation\n"
		"	an instantiation of the variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\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_check", _wrap_IBayesNet_check, METH_O, "\n"
		"\n"
		"Check if the BayesNet is consistent (variables, CPT, ...)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List[str]\n"
		"  list of found issues\n"
		"\n"
		""},
	 { "IBayesNet___eq__", _wrap_IBayesNet___eq__, METH_VARARGS, NULL},
	 { "IBayesNet___ne__", _wrap_IBayesNet___ne__, METH_VARARGS, NULL},
	 { "IBayesNet_dim", _wrap_IBayesNet_dim, METH_O, "\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"
		"\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"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the smallest value in the CPTs of the IBayesNet\n"
		"\n"
		""},
	 { "IBayesNet_maxParam", _wrap_IBayesNet_maxParam, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the biggest value in the CPTs of the BayesNet\n"
		"\n"
		""},
	 { "IBayesNet_minNonZeroParam", _wrap_IBayesNet_minNonZeroParam, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the smallest value (not equal to 0) in the CPTs of the IBayesNet\n"
		"\n"
		""},
	 { "IBayesNet_maxNonOneParam", _wrap_IBayesNet_maxNonOneParam, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	The biggest value (not equal to 1) in the CPTs of the BayesNet\n"
		"\n"
		""},
	 { "IBayesNet_toDot", _wrap_IBayesNet_toDot, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format\n"
		"\n"
		""},
	 { "IBayesNet_evEq", _wrap_IBayesNet_evEq, METH_VARARGS, "\n"
		"\n"
		"This method is used to set an observation on a quasi-continuous variables (:class:`pyagrum\n"
		".DiscretizedVariable` with a large number of ticks)  that the variable is equal to a given value.\n"
		"\n"
		"Note\n"
		"----\n"
		"  - see also :meth:`Tensor.evEq`\n"
		"  - see also :meth:`BayesNet.evGt`, :meth:`BayesNet.evLt`, :meth:`BayesNet.evIn`\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> import pyagrum as gum\n"
		">>> bn = gum.fastBN('A[0:10:20]'') # DiscretizedVariable from 0 to 10 in 20 steps\n"
		">>> print(bn.evEqu('A',5)\n"
		"  A                                                                                                                                                                                                    |\n"
		"[0;0.5[  |[0.5;1[  |[1;1.5[  |[1.5;2[  |[2;2.5[  |[2.5;3[  |[3;3.5[  |[3.5;4[  |[4;4.5[  |[4.5;5[  |[5;5.5[  |[5.5;6[  |[6;6.5[  |[6.5;7[  |[7;7.5[  |[7.5;8[  |[8;8.5[  |[8.5;9[  |[9;9.5[  |[9.5;10] |\n"
		"---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|\n"
		" 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 1.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  |\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : Union[int,str]\n"
		"  the current name or the id of the variable\n"
		"value: float\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Tensor\n"
		"  The representation of the evidence as a :class:`~pyagrum.Tensor`.\n"
		"\n"
		""},
	 { "IBayesNet_evIn", _wrap_IBayesNet_evIn, METH_VARARGS, "\n"
		"\n"
		"This method is used to set an obvervation on a quasi-continuous variables (:class:`pyagrum\n"
		".DiscretizedVariable` with a large number of ticks) that the variable is less than a given value.\n"
		"\n"
		"Note\n"
		"----\n"
		"  - see also :meth:`Tensor.evIn`\n"
		"  - see also :meth:`BayesNet.evEq`, :meth:`BayesNet.evGt`, :meth:`BayesNet.evLt`\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : Union[int,str]\n"
		"  the current name or the id of the variable\n"
		"valueMin: float\n"
		"  the minimum value\n"
		"valueMax: float\n"
		"  the maximum value\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  The representation of the evidence as a :class:`~pyagrum.Tensor`.\n"
		"\n"
		""},
	 { "IBayesNet_evLt", _wrap_IBayesNet_evLt, METH_VARARGS, "\n"
		"\n"
		"This method is used to set an obvervation on a quasi-continuous variables (:class:`pyagrum\n"
		".DiscretizedVariable` with a large number of ticks) that the variable is less than a given value.\n"
		"\n"
		"Note\n"
		"----\n"
		"  - see also :meth:`Tensor.evLt`\n"
		"  - see also :meth:`BayesNet.evEq`, :meth:`BayesNet.evGt`, :meth:`BayesNet.evIn`\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : Union[int,str]\n"
		"  the current name or the id of the variable\n"
		"value: float\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Tensor\n"
		"  The representation of the evidence as a :class:`~pyagrum.Tensor`.\n"
		"\n"
		""},
	 { "IBayesNet_evGt", _wrap_IBayesNet_evGt, METH_VARARGS, "\n"
		"\n"
		"This method is used to set an obvervation on a quasi-continuous variables (:class:`pyagrum\n"
		".DiscretizedVariable` with a large number of ticks) that the variable greater than a given value.\n"
		"\n"
		"Note\n"
		"----\n"
		"  - see also :meth:`Tensor.evGt`\n"
		"  - see also :meth:`BayesNet.evEq`, :meth:`BayesNet.evLt`, :meth:`BayesNet.evIn`\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> import pyagrum as gum\n"
		">>> bn = gum.fastBN('A[0:10:20]'') # DiscretizedVariable from 0 to 10 in 20 steps\n"
		">>> print(bn.eGt('A',5)\n"
		"  A                                                                                                                                                                                                    |\n"
		"[0;0.5[  |[0.5;1[  |[1;1.5[  |[1.5;2[  |[2;2.5[  |[2.5;3[  |[3;3.5[  |[3.5;4[  |[4;4.5[  |[4.5;5[  |[5;5.5[  |[5.5;6[  |[6;6.5[  |[6.5;7[  |[7;7.5[  |[7.5;8[  |[8;8.5[  |[8.5;9[  |[9;9.5[  |[9.5;10] |\n"
		"---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|---------|\n"
		" 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 0.0000  | 1.0000  | 1.0000  | 1.0000  | 1.0000  | 1.0000  | 1.0000  | 1.0000  | 1.0000  | 1.0000  | 1.0000  |\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : Union[int,str]\n"
		"  the current name or the id of the variable\n"
		"value: float\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Tensor\n"
		"  The representation of the evidence as a :class:`~pyagrum.Tensor`.\n"
		"\n"
		""},
	 { "IBayesNet_memoryFootprint", _wrap_IBayesNet_memoryFootprint, METH_O, "\n"
		"\n"
		"get the size (in byte) of the (main footprint) of the BayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the size in byte of the representation (of the parameters) of the BayesNet\n"
		"\n"
		""},
	 { "IBayesNet_ids", _wrap_IBayesNet_ids, METH_VARARGS, "\n"
		"\n"
		"List of ids for a list of names of variables in the model\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lov : List[str]\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List[int]\n"
		"	The ids for the list of names of the graph variables\n"
		"\n"
		""},
	 { "IBayesNet_nodeset", _wrap_IBayesNet_nodeset, METH_VARARGS, "\n"
		"\n"
		"Set of ids for a list of names of variables in the model\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lov : List[str]\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"	The set of ids for the list of names of the graph variables\n"
		"\n"
		""},
	 { "IBayesNet_minimalCondSet", _wrap_IBayesNet_minimalCondSet, METH_VARARGS, "\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[int]\n"
		"	The ids of the targets\n"
		"list : List[int]\n"
		"	The list of available variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"	The minimal set of variables\n"
		"\n"
		""},
	 { "IBayesNet_isIndependent", _wrap_IBayesNet_isIndependent, METH_VARARGS, "\n"
		"\n"
		"check if nodes X and nodes Y are independent given nodes Z\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"\n"
		"Raises\n"
		"------\n"
		"InvalidArgument\n"
		"  if X and Y share variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if X and Y are independent given Z in the model\n"
		"\n"
		""},
	 { "IBayesNet_names", _wrap_IBayesNet_names, METH_O, "\n"
		"\n"
		"Set of names of variables in the model\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[str]\n"
		"	The names of the graph variables\n"
		"\n"
		""},
	 { "IBayesNet_nodes", _wrap_IBayesNet_nodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"    the set of ids\n"
		"\n"
		""},
	 { "IBayesNet_arcs", _wrap_IBayesNet_arcs, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	The lisf of arcs in the IBayesNet\n"
		"\n"
		""},
	 { "IBayesNet_parents", _wrap_IBayesNet_parents, METH_VARARGS, "\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"
		"\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_family", _wrap_IBayesNet_family, METH_VARARGS, "\n"
		"\n"
		"give the set of parents of a node and the node\n"
		"\n"
		"Parameters\n"
		"---------\n"
		"norid : str|int\n"
		"  the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of nodeId of the family of the node `norid`\n"
		"\n"
		""},
	 { "IBayesNet_descendants", _wrap_IBayesNet_descendants, METH_VARARGS, "\n"
		"\n"
		"give the set of nodeid of descendants of a node\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"norid : str|int\n"
		"  the name or the id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of ids of the descendants of node `norid`.\n"
		"\n"
		""},
	 { "IBayesNet_ancestors", _wrap_IBayesNet_ancestors, METH_VARARGS, "\n"
		"\n"
		"give the set of nodeid of ancestors of a node\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"norid : str|int\n"
		"  the name or the id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of ids of the ancestors of node `norid`.\n"
		"\n"
		""},
	 { "IBayesNet_moralizedAncestralGraph", _wrap_IBayesNet_moralizedAncestralGraph, METH_VARARGS, "\n"
		"\n"
		"build a UndiGraph by moralizing the Ancestral Graph of a list of nodes\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nodes : str|int|List[str|int]\n"
		"  the list of of nodeIds or names\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"  gum.UndiGraph only knows NodeId. Hence the moralized ancestral graph does not include the names of the variables.graph\n"
		"\n"
		"Returns\n"
		"-------\n"
		"gum.UndiGraph\n"
		"  the moralized ancestral graph of the nodes\n"
		"\n"
		""},
	 { "IBayesNet___repr__", _wrap_IBayesNet___repr__, METH_O, NULL},
	 { "IBayesNet___str__", _wrap_IBayesNet___str__, METH_O, NULL},
	 { "IBayesNet_swigregister", IBayesNet_swigregister, METH_O, NULL},
	 { "BayesNet_fastPrototype", _wrap_BayesNet_fastPrototype, METH_VARARGS, "\n"
		"\n"
		"Create a Bayesian network with a dot-like syntax which specifies:\n"
		"    - the structure 'a->b->c;b->d<-e;'.\n"
		"    - the type of the variables with different syntax:\n"
		"\n"
		"      - by default, a variable is a binary `pyagrum.RangeVariable` using the default domain size ([2])\n"
		"      - with 'a[10]', the variable is a `pyagrum.RangeVariable` using 10 as domain size (from 0 to 9)\n"
		"      - with 'a[3,7]', the variable is a `pyagrum.RangeVariable` using a domainSize from 3 to 7\n"
		"      - with 'a[1,3.14,5,6.2]', the variable is a `pyagrum.DiscretizedVariable` using the given ticks (at least 3 values)\n"
		"      - with 'a[0.0:3.14:10]', the variable is a `pyagrum.DiscretizedVariable` of 10 intervals of same width from 0 to 3.14 (including both)\n"
		"      - with 'a{top|middle|bottom}', the variable is a `pyagrum.LabelizedVariable` using the given labels.\n"
		"      - with 'a{-1|5|0|3}', the variable is a `pyagrum.IntegerVariable` using the sorted given values.\n"
		"      - with 'a{-0.5|5.01|0|3.1415}', the variable is a `pyagrum.NumericalDiscreteVariable` using the sorted given values.\n"
		"\n"
		"Note\n"
		"----\n"
		"  - If the dot-like string contains such a specification more than once for a variable, the first specification will be used.\n"
		"  - the CPTs are randomly generated.\n"
		"  - see also the function pyagrum.fastBN.\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> import pyagrum as gum\n"
		">>> bn=pyagrum.BayesNet.fastPrototype('A->B[1,3]<-C{yes|No}->D[2,4]<-E[1,2.5,3.9]',6)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dotlike : str\n"
		"        the string containing the specification\n"
		"domainSize : int or str\n"
		"        the default domain size or the default domain for variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BayesNet\n"
		"        the resulting Bayesian network\n"
		"\n"
		""},
	 { "delete_BayesNet", _wrap_delete_BayesNet, METH_O, NULL},
	 { "new_BayesNet", _wrap_new_BayesNet, METH_VARARGS, NULL},
	 { "BayesNet_cpt", _wrap_BayesNet_cpt, METH_VARARGS, "\n"
		"\n"
		"Returns the CPT of a variable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"VarId :  Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"	The variable's CPT.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    If no variable's id matches varId.\n"
		"\n"
		""},
	 { "BayesNet_variableNodeMap", _wrap_BayesNet_variableNodeMap, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.variableNodeMap\n"
		"	the variable node map\n"
		"\n"
		""},
	 { "BayesNet_add", _wrap_BayesNet_add, METH_VARARGS, "\n"
		"\n"
		"Add a variable to the pyagrum.BayesNet.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyagrum.DiscreteVariable\n"
		"	the variable added\n"
		"descr : str\n"
		"	the description of the variable (following :ref:`fast syntax<Quick specification of (randomly parameterized) graphical models>`)\n"
		"nbrmod : int\n"
		"	the number 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"
		"pyagrum.DuplicateLabel\n"
		"    If variable.name() or id is already used in this pyagrum.BayesNet.\n"
		"pyagrum.NotAllowed\n"
		"    If nbrmod is less than 2\n"
		"\n"
		""},
	 { "BayesNet_clear", _wrap_BayesNet_clear, METH_O, "\n"
		"\n"
		"Clear the whole BayesNet\n"
		"\n"
		""},
	 { "BayesNet_erase", _wrap_BayesNet_erase, METH_VARARGS, "\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::Tensor.\n"
		"\n"
		"If no variable matches the given id, then nothing is done.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : Union[int,str,pyagrum.DiscreteVariable]\n"
		"	the current name, the id of the variable or a reference to the variable\n"
		"\n"
		""},
	 { "BayesNet_variable", _wrap_BayesNet_variable, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "BayesNet_changeVariableName", _wrap_BayesNet_changeVariableName, METH_VARARGS, "\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"
		"var : Union[int,str]\n"
		"	the current name or the id of the variable\n"
		"new_name : str\n"
		"	the new name of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.DuplicateLabel\n"
		"    If new_name is already used in this BayesNet.\n"
		"pyagrum.NotFound\n"
		"    If no variable matches id.\n"
		"\n"
		""},
	 { "BayesNet_changeVariableLabel", _wrap_BayesNet_changeVariableLabel, METH_VARARGS, "\n"
		"\n"
		"change the label of the variable associated to nodeId to the new value.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : Union[int,str]\n"
		"	the current name or the id of the variable\n"
		"old_label : str\n"
		"	the new label\n"
		"new_label : str\n"
		"	the new label\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.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"
		"\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"
		"pyagrum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "BayesNet_idFromName", _wrap_BayesNet_idFromName, METH_VARARGS, "\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"
		"Notes\n"
		"-----\n"
		"  A convenient shortcut for `g.variableFromName(name)` is `g[name]`.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	The variable's node id.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"	If name does not match a variable in the graph\n"
		"\n"
		""},
	 { "BayesNet_variableFromName", _wrap_BayesNet_variableFromName, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "BayesNet_addArc", _wrap_BayesNet_addArc, METH_VARARGS, "\n"
		"\n"
		"Add an arc in the BN, and update arc.head's CPT.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"head : Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"head : Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidEdge\n"
		"    If arc.tail and/or arc.head are not in the BN.\n"
		"pyagrum.DuplicateElement\n"
		"    If the arc already exists.\n"
		"\n"
		""},
	 { "BayesNet_eraseArc", _wrap_BayesNet_eraseArc, METH_VARARGS, "\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 when calling eraseArc(arc)\n"
		"	The arc to be removed.\n"
		"head : Union[int,str]\n"
		"	a variable's id (int) or name for the head when calling eraseArc(head,tail)\n"
		"tail : Union[int,str]\n"
		"	a variable's id (int) or name for the tail when calling eraseArc(head,tail)\n"
		"\n"
		""},
	 { "BayesNet_beginTopologyTransformation", _wrap_BayesNet_beginTopologyTransformation, METH_O, "\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"
		"\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"
		"\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"
		"pyagrum.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"
		"\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 : float\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"
		"pyagrum.DuplicateElement\n"
		"    If id is already used\n"
		"\n"
		""},
	 { "BayesNet_addNoisyORNet", _wrap_BayesNet_addNoisyORNet, METH_VARARGS, "\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 : float\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"
		"\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 : float\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"
		"pyagrum.DuplicateElement\n"
		"    If id is already used\n"
		"\n"
		""},
	 { "BayesNet_addNoisyAND", _wrap_BayesNet_addNoisyAND, METH_VARARGS, "\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 : float\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"
		"pyagrum.DuplicateElement\n"
		"    If id is already used\n"
		"\n"
		""},
	 { "BayesNet_addLogit", _wrap_BayesNet_addLogit, METH_VARARGS, "\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 : float\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"
		"pyagrum.DuplicateElement\n"
		"    If id is already used\n"
		"\n"
		""},
	 { "BayesNet_addOR", _wrap_BayesNet_addOR, METH_VARARGS, "\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"
		"pyagrum.SizeError\n"
		"    If variable.domainSize()>2\n"
		"\n"
		""},
	 { "BayesNet_addAND", _wrap_BayesNet_addAND, METH_VARARGS, "\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"
		"pyagrum.SizeError\n"
		"    If variable.domainSize()>2\n"
		"\n"
		""},
	 { "BayesNet_addAMPLITUDE", _wrap_BayesNet_addAMPLITUDE, METH_VARARGS, "\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\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_addSUM", _wrap_BayesNet_addSUM, METH_VARARGS, "\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"
		"\n"
		"Add an arc in the BN, and update arc.head's CPT.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"head : Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"tail : Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"causalWeight : float\n"
		"	the added causal weight\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArc\n"
		"    If arc.tail and/or arc.head are not in the BN.\n"
		"pyagrum.InvalidArc\n"
		"    If variable in arc.head is not a NoisyOR variable.\n"
		"\n"
		""},
	 { "BayesNet_generateCPTs", _wrap_BayesNet_generateCPTs, METH_O, "\n"
		"\n"
		"Randomly generates CPTs for a given structure.\n"
		"\n"
		""},
	 { "BayesNet_generateCPT", _wrap_BayesNet_generateCPT, METH_VARARGS, "\n"
		"\n"
		"Randomly generate CPT for a given node in a given structure.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node : Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"\n"
		""},
	 { "BayesNet_changeTensor", _wrap_BayesNet_changeTensor, METH_VARARGS, "\n"
		"\n"
		"change the CPT associated to nodeId to newPot delete the old CPT associated to nodeId.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : Union[int,str]\n"
		"	the current name or the id of the variable\n"
		"newPot : pyagrum.Tensor\n"
		"	the new tensor\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotAllowed\n"
		"    If newPot has not the same signature as __probaMap[NodeId]\n"
		"\n"
		""},
	 { "BayesNet_dag", _wrap_BayesNet_dag, METH_O, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of nodes in the graph\n"
		"\n"
		""},
	 { "BayesNet_log10DomainSize", _wrap_BayesNet_log10DomainSize, METH_O, "\n"
		"\n"
		"returns the log10 of the domain size of the model defined as the product of the domain sizes of the variables in the model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the log10 domain size.\n"
		"\n"
		""},
	 { "BayesNet_ids", _wrap_BayesNet_ids, METH_VARARGS, "\n"
		"\n"
		"List of ids for a list of names of variables in the model\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lov : List[str]\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List[int]\n"
		"	The ids for the list of names of the graph variables\n"
		"\n"
		""},
	 { "BayesNet_nodeset", _wrap_BayesNet_nodeset, METH_VARARGS, "\n"
		"\n"
		"Set of ids for a list of names of variables in the model\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lov : List[str]\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"	The set of ids for the list of names of the graph variables\n"
		"\n"
		""},
	 { "BayesNet_minimalCondSet", _wrap_BayesNet_minimalCondSet, METH_VARARGS, "\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[int]\n"
		"	The ids of the targets\n"
		"list : List[int]\n"
		"	The list of available variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"	The minimal set of variables\n"
		"\n"
		""},
	 { "BayesNet_isIndependent", _wrap_BayesNet_isIndependent, METH_VARARGS, "\n"
		"\n"
		"check if nodes X and nodes Y are independent given nodes Z\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"\n"
		"Raises\n"
		"------\n"
		"InvalidArgument\n"
		"  if X and Y share variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if X and Y are independent given Z in the model\n"
		"\n"
		""},
	 { "BayesNet_names", _wrap_BayesNet_names, METH_O, "\n"
		"\n"
		"Set of names of variables in the model\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[str]\n"
		"	The names of the graph variables\n"
		"\n"
		""},
	 { "BayesNet_nodes", _wrap_BayesNet_nodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"    the set of ids\n"
		"\n"
		""},
	 { "BayesNet_arcs", _wrap_BayesNet_arcs, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	The lisf of arcs in the IBayesNet\n"
		"\n"
		""},
	 { "BayesNet_parents", _wrap_BayesNet_parents, METH_VARARGS, "\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"
		""},
	 { "BayesNet_children", _wrap_BayesNet_children, METH_VARARGS, "\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"
		""},
	 { "BayesNet_family", _wrap_BayesNet_family, METH_VARARGS, "\n"
		"\n"
		"give the set of parents of a node and the node\n"
		"\n"
		"Parameters\n"
		"---------\n"
		"norid : str|int\n"
		"  the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of nodeId of the family of the node `norid`\n"
		"\n"
		""},
	 { "BayesNet_descendants", _wrap_BayesNet_descendants, METH_VARARGS, "\n"
		"\n"
		"give the set of nodeid of descendants of a node\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"norid : str|int\n"
		"  the name or the id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of ids of the descendants of node `norid`.\n"
		"\n"
		""},
	 { "BayesNet_ancestors", _wrap_BayesNet_ancestors, METH_VARARGS, "\n"
		"\n"
		"give the set of nodeid of ancestors of a node\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"norid : str|int\n"
		"  the name or the id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of ids of the ancestors of node `norid`.\n"
		"\n"
		""},
	 { "BayesNet_moralizedAncestralGraph", _wrap_BayesNet_moralizedAncestralGraph, METH_VARARGS, "\n"
		"\n"
		"build a UndiGraph by moralizing the Ancestral Graph of a list of nodes\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nodes : str|int|List[str|int]\n"
		"  the list of of nodeIds or names\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"  gum.UndiGraph only knows NodeId. Hence the moralized ancestral graph does not include the names of the variables.graph\n"
		"\n"
		"Returns\n"
		"-------\n"
		"gum.UndiGraph\n"
		"  the moralized ancestral graph of the nodes\n"
		"\n"
		""},
	 { "BayesNet_loadBIF", _wrap_BayesNet_loadBIF, METH_VARARGS, "\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"
		"pyagrum.IOError\n"
		"    If file not found\n"
		"pyagrum.FatalError\n"
		"    If file is not valid\n"
		"\n"
		""},
	 { "BayesNet_saveBIF", _wrap_BayesNet_saveBIF, METH_VARARGS, "\n"
		"\n"
		"Save the BayesNet in a BIF file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"allowModificationWhenSaving: bool\n"
		"        False by default.\n"
		"        if true, syntax errors are corrected when saving the file. If false, they throw a FatalError.\n"
		"\n"
		""},
	 { "BayesNet_loadDSL", _wrap_BayesNet_loadDSL, METH_VARARGS, "\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"
		"pyagrum.IOError\n"
		"    If file not found\n"
		"pyagrum.FatalError\n"
		"    If file is not valid\n"
		"\n"
		""},
	 { "BayesNet_loadXDSL", _wrap_BayesNet_loadXDSL, METH_VARARGS, "\n"
		"\n"
		"Load a XDSL 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"
		"pyagrum.IOError\n"
		"    If file not found\n"
		"pyagrum.FatalError\n"
		"    If file is not valid\n"
		"\n"
		""},
	 { "BayesNet_saveDSL", _wrap_BayesNet_saveDSL, METH_VARARGS, "\n"
		"\n"
		"Save the BayesNet in a DSL file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"allowModificationWhenSaving: bool\n"
		"        False by default.\n"
		"        if true, syntax errors are corrected when saving the file. If false, they throw a FatalError.\n"
		"\n"
		""},
	 { "BayesNet_saveXDSL", _wrap_BayesNet_saveXDSL, METH_VARARGS, "\n"
		"\n"
		"Save the BayesNet in a XDSL file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"allowModificationWhenSaving: bool\n"
		"        (not used).\n"
		"        if true, syntax errors are corrected when saving the file. If false, they throw a FatalError.\n"
		"\n"
		""},
	 { "BayesNet_loadNET", _wrap_BayesNet_loadNET, METH_VARARGS, "\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"
		"pyagrum.IOError\n"
		"    If file not found\n"
		"pyagrum.FatalError\n"
		"    If file is not valid\n"
		"\n"
		""},
	 { "BayesNet_saveNET", _wrap_BayesNet_saveNET, METH_VARARGS, "\n"
		"\n"
		"Save the BayesNet in a NET file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"allowModificationWhenSaving: bool\n"
		"        False by default.\n"
		"        if true, syntax errors are corrected when saving the file. If false, they throw a FatalError.\n"
		"\n"
		""},
	 { "BayesNet_loadO3PRM", _wrap_BayesNet_loadO3PRM, METH_VARARGS, "\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"
		"pyagrum.IOError\n"
		"    If file not found\n"
		"pyagrum.FatalError\n"
		"    If file is not valid\n"
		"\n"
		""},
	 { "BayesNet_saveO3PRM", _wrap_BayesNet_saveO3PRM, METH_VARARGS, "\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"
		"allowModificationWhenSaving: bool\n"
		"        False by default.\n"
		"        if true, syntax errors are corrected when saving the file. If false, they throw a FatalError.\n"
		"\n"
		""},
	 { "BayesNet_loadBIFXML", _wrap_BayesNet_loadBIFXML, METH_VARARGS, "\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"
		"pyagrum.IOError\n"
		"    If file not found\n"
		"pyagrum.FatalError\n"
		"    If file is not valid\n"
		"\n"
		""},
	 { "BayesNet_saveBIFXML", _wrap_BayesNet_saveBIFXML, METH_VARARGS, "\n"
		"\n"
		"Save the BayesNet in a BIFXML file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"allowModificationWhenSaving: bool\n"
		"        False by default.\n"
		"        if true, syntax errors are corrected when saving the file. If false, they throw a FatalError.\n"
		"\n"
		""},
	 { "BayesNet_loadUAI", _wrap_BayesNet_loadUAI, METH_VARARGS, "\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"
		"pyagrum.IOError\n"
		"    If file not found\n"
		"pyagrum.FatalError\n"
		"    If file is not valid\n"
		"\n"
		""},
	 { "BayesNet_saveUAI", _wrap_BayesNet_saveUAI, METH_VARARGS, "\n"
		"\n"
		"Save the BayesNet in an UAI file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"allowModificationWhenSaving: bool\n"
		"        False by default.\n"
		"        if true, syntax errors are corrected when saving the file. If false, they throw a FatalError.\n"
		"\n"
		""},
	 { "BayesNet_contextualize", _wrap_BayesNet_contextualize, METH_VARARGS, NULL},
	 { "BayesNet___repr__", _wrap_BayesNet___repr__, METH_O, NULL},
	 { "BayesNet___str__", _wrap_BayesNet___str__, METH_O, NULL},
	 { "BayesNet_swigregister", BayesNet_swigregister, METH_O, NULL},
	 { "BayesNet_swiginit", BayesNet_swiginit, METH_VARARGS, NULL},
	 { "new_BayesNetFragment", _wrap_new_BayesNetFragment, METH_O, NULL},
	 { "delete_BayesNetFragment", _wrap_delete_BayesNetFragment, METH_O, NULL},
	 { "BayesNetFragment_whenNodeAdded", _wrap_BayesNetFragment_whenNodeAdded, METH_VARARGS, NULL},
	 { "BayesNetFragment_whenNodeDeleted", _wrap_BayesNetFragment_whenNodeDeleted, METH_VARARGS, NULL},
	 { "BayesNetFragment_whenArcAdded", _wrap_BayesNetFragment_whenArcAdded, METH_VARARGS, NULL},
	 { "BayesNetFragment_whenArcDeleted", _wrap_BayesNetFragment_whenArcDeleted, METH_VARARGS, NULL},
	 { "BayesNetFragment_cpt", _wrap_BayesNetFragment_cpt, METH_VARARGS, "\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.Tensor\n"
		"	The variable's CPT.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"	If no variable's id matches varId.\n"
		"\n"
		""},
	 { "BayesNetFragment_variableNodeMap", _wrap_BayesNetFragment_variableNodeMap, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.variableNodeMap\n"
		"	the variable node map\n"
		"\n"
		""},
	 { "BayesNetFragment_variable", _wrap_BayesNetFragment_variable, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "BayesNetFragment_nodeId", _wrap_BayesNetFragment_nodeId, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "BayesNetFragment_idFromName", _wrap_BayesNetFragment_idFromName, METH_VARARGS, "\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"
		"Notes\n"
		"-----\n"
		"  A convenient shortcut for `g.variableFromName(name)` is `g[name]`.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	The variable's node id.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"	If name does not match a variable in the graph\n"
		"\n"
		""},
	 { "BayesNetFragment_variableFromName", _wrap_BayesNetFragment_variableFromName, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "BayesNetFragment_toDot", _wrap_BayesNetFragment_toDot, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format\n"
		"\n"
		""},
	 { "BayesNetFragment_isInstalledNode", _wrap_BayesNetFragment_isInstalledNode, METH_VARARGS, "\n"
		"\n"
		"Check if a node is in the fragment\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int, str\n"
		"	the id or the name of the variable.\n"
		"\n"
		""},
	 { "BayesNetFragment_installNode", _wrap_BayesNetFragment_installNode, METH_VARARGS, "\n"
		"\n"
		"Add a node to the fragment. The arcs that can be added between installed nodes are created.\n"
		"No specific CPT are created. Then either the parents of the node are already in the fragment\n"
		"and the node is consistant, or the parents are not in the fragment and the node is not consistant.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int, str\n"
		"	the id or the name of the variable.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"  if the node is not found.\n"
		"\n"
		""},
	 { "BayesNetFragment_installAscendants", _wrap_BayesNetFragment_installAscendants, METH_VARARGS, "\n"
		"\n"
		"Add the variable and all its ascendants in the fragment. No inconsistant node are created.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int, str\n"
		"	the id or the name of the variable.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.NotFound\n"
		"  if the node is not found.\n"
		"\n"
		""},
	 { "BayesNetFragment_uninstallNode", _wrap_BayesNetFragment_uninstallNode, METH_VARARGS, "\n"
		"\n"
		"Remove a node from the fragment. The fragment can become inconsistant.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int, str\n"
		"	the id or the name of the variable.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"  if the node is not found.\n"
		"\n"
		""},
	 { "BayesNetFragment_installMarginal", _wrap_BayesNetFragment_installMarginal, METH_VARARGS, "\n"
		"\n"
		"Install a local marginal for a node. Doing so, it removes the parents of the node in the fragment.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int, str\n"
		"	the id or the name of the variable.\n"
		"pot : Tensor\n"
		"  the Tensor (marginal) to install\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"  if the node is not found.\n"
		"\n"
		""},
	 { "BayesNetFragment_installCPT", _wrap_BayesNetFragment_installCPT, METH_VARARGS, "\n"
		"\n"
		"Install a local CPT for a node. Doing so, it changes the parents of the node in the fragment.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int, str\n"
		"	the id or the name of the variable.\n"
		"pot : Tensor\n"
		"  the Tensor to install\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"  if the node is not found.\n"
		"\n"
		""},
	 { "BayesNetFragment_uninstallCPT", _wrap_BayesNetFragment_uninstallCPT, METH_VARARGS, "\n"
		"\n"
		"Remove a local CPT. The fragment can become inconsistant.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int, str\n"
		"	the id or the name of the variable.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"  if the node is not found.\n"
		"\n"
		""},
	 { "BayesNetFragment_checkConsistency", _wrap_BayesNetFragment_checkConsistency, METH_VARARGS, "\n"
		"\n"
		"If a variable is added to the fragment but not its parents, there is no CPT consistant for this variable. This function checks the consistency for a variable of for all.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"\n"
		"n : int, str (optional)\n"
		"	the id or the name of the variable. If no argument, the function checks all the variables.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"boolean\n"
		"	True if the variable(s) is consistant.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.NotFound\n"
		"  if the node is not found.\n"
		"\n"
		""},
	 { "BayesNetFragment_toBN", _wrap_BayesNetFragment_toBN, METH_O, "\n"
		"\n"
		"Create a BayesNet from a fragment.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"  if the fragment is not consistent.\n"
		"\n"
		""},
	 { "BayesNetFragment_dag", _wrap_BayesNetFragment_dag, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DAG\n"
		"	a constant reference to the dag of this BayesNet.\n"
		"\n"
		""},
	 { "BayesNetFragment_ids", _wrap_BayesNetFragment_ids, METH_VARARGS, "\n"
		"\n"
		"List of ids for a list of names of variables in the model\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lov : List[str]\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List[int]\n"
		"	The ids for the list of names of the graph variables\n"
		"\n"
		""},
	 { "BayesNetFragment_nodeset", _wrap_BayesNetFragment_nodeset, METH_VARARGS, "\n"
		"\n"
		"Set of ids for a list of names of variables in the model\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lov : List[str]\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"	The set of ids for the list of names of the graph variables\n"
		"\n"
		""},
	 { "BayesNetFragment_minimalCondSet", _wrap_BayesNetFragment_minimalCondSet, METH_VARARGS, "\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[int]\n"
		"	The ids of the targets\n"
		"list : List[int]\n"
		"	The list of available variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"	The minimal set of variables\n"
		"\n"
		""},
	 { "BayesNetFragment_isIndependent", _wrap_BayesNetFragment_isIndependent, METH_VARARGS, "\n"
		"\n"
		"check if nodes X and nodes Y are independent given nodes Z\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"\n"
		"Raises\n"
		"------\n"
		"InvalidArgument\n"
		"  if X and Y share variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if X and Y are independent given Z in the model\n"
		"\n"
		""},
	 { "BayesNetFragment_names", _wrap_BayesNetFragment_names, METH_O, "\n"
		"\n"
		"Set of names of variables in the model\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[str]\n"
		"	The names of the graph variables\n"
		"\n"
		""},
	 { "BayesNetFragment_nodes", _wrap_BayesNetFragment_nodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"    the set of ids\n"
		"\n"
		""},
	 { "BayesNetFragment_arcs", _wrap_BayesNetFragment_arcs, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	The lisf of arcs in the IBayesNet\n"
		"\n"
		""},
	 { "BayesNetFragment_parents", _wrap_BayesNetFragment_parents, METH_VARARGS, "\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"
		""},
	 { "BayesNetFragment_children", _wrap_BayesNetFragment_children, METH_VARARGS, "\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"
		""},
	 { "BayesNetFragment_family", _wrap_BayesNetFragment_family, METH_VARARGS, "\n"
		"\n"
		"give the set of parents of a node and the node\n"
		"\n"
		"Parameters\n"
		"---------\n"
		"norid : str|int\n"
		"  the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of nodeId of the family of the node `norid`\n"
		"\n"
		""},
	 { "BayesNetFragment_descendants", _wrap_BayesNetFragment_descendants, METH_VARARGS, "\n"
		"\n"
		"give the set of nodeid of descendants of a node\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"norid : str|int\n"
		"  the name or the id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of ids of the descendants of node `norid`.\n"
		"\n"
		""},
	 { "BayesNetFragment_ancestors", _wrap_BayesNetFragment_ancestors, METH_VARARGS, "\n"
		"\n"
		"give the set of nodeid of ancestors of a node\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"norid : str|int\n"
		"  the name or the id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of ids of the ancestors of node `norid`.\n"
		"\n"
		""},
	 { "BayesNetFragment_moralizedAncestralGraph", _wrap_BayesNetFragment_moralizedAncestralGraph, METH_VARARGS, "\n"
		"\n"
		"build a UndiGraph by moralizing the Ancestral Graph of a list of nodes\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nodes : str|int|List[str|int]\n"
		"  the list of of nodeIds or names\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"  gum.UndiGraph only knows NodeId. Hence the moralized ancestral graph does not include the names of the variables.graph\n"
		"\n"
		"Returns\n"
		"-------\n"
		"gum.UndiGraph\n"
		"  the moralized ancestral graph of the nodes\n"
		"\n"
		""},
	 { "BayesNetFragment_swigregister", BayesNetFragment_swigregister, METH_O, NULL},
	 { "BayesNetFragment_swiginit", BayesNetFragment_swiginit, METH_VARARGS, NULL},
	 { "new_LazyPropagation", _wrap_new_LazyPropagation, METH_VARARGS, NULL},
	 { "delete_LazyPropagation", _wrap_delete_LazyPropagation, METH_O, NULL},
	 { "LazyPropagation_setTriangulation", _wrap_LazyPropagation_setTriangulation, METH_VARARGS, NULL},
	 { "LazyPropagation_setRelevantTensorsFinderType", _wrap_LazyPropagation_setRelevantTensorsFinderType, METH_VARARGS, "\n"
		"\n"
		"sets how we determine the relevant tensors to combine\n"
		"\n"
		"When a clique sends a message to a separator, it first constitute the set of the tensors it contains and of the tensors contained in the messages it received. If RelevantTensorsFinderType = FIND_ALL, all these tensors are combined and projected to produce the message sent to the separator. If RelevantTensorsFinderType = DSEP_BAYESBALL_NODES, then only the set of tensors 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_TENSORS\n"
		"3 = DSEP_KOLLER_FRIEDMAN_2009\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type : int\n"
		"  the finder type\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If type is not implemented\n"
		"\n"
		""},
	 { "LazyPropagation_setFindBarrenNodesType", _wrap_LazyPropagation_setFindBarrenNodesType, METH_VARARGS, "\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"
		"pyagrum.InvalidArgument\n"
		"  If type is not implemented\n"
		"\n"
		""},
	 { "LazyPropagation_joinTree", _wrap_LazyPropagation_joinTree, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CliqueGraph\n"
		"  the current join tree used\n"
		"\n"
		""},
	 { "LazyPropagation_junctionTree", _wrap_LazyPropagation_junctionTree, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CliqueGraph\n"
		"  the current junction tree\n"
		"\n"
		""},
	 { "LazyPropagation_evidenceProbability", _wrap_LazyPropagation_evidenceProbability, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the probability of evidence\n"
		"\n"
		""},
	 { "LazyPropagation_mpe", _wrap_LazyPropagation_mpe, METH_O, "\n"
		"\n"
		"Find the Most Probable Explanation (MPE) given the evidence (if any) added into LazyPropagation\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Instantiation\n"
		"  An instantiation of all the variables of the Bayes net representing the Most Probable Explanation.\n"
		"\n"
		""},
	 { "LazyPropagation_mpeLog2Posterior", _wrap_LazyPropagation_mpeLog2Posterior, METH_O, "\n"
		"\n"
		"Find the Most Probable Explanation (MPE) given the evidence (if any) added into LazyPropagation as well as the log2 of its posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tuple[pyagrum.Instantiation, float]\n"
		"    A tuple with the instantiation of all the variables of the Bayes net representing the Most Probable Explanation and the log2 of its posterior probability\n"
		"\n"
		""},
	 { "LazyPropagation_makeInference", _wrap_LazyPropagation_makeInference, METH_O, "\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_addEvidence", _wrap_LazyPropagation_addEvidence, METH_VARARGS, "\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"
		"  pyagrum.InvalidArgument\n"
		"    If the node already has an evidence\n"
		"  pyagrum.InvalidArgument\n"
		"    If val is not a value for the node\n"
		"  pyagrum.InvalidArgument\n"
		"    If the size of vals is different from the domain side of the node\n"
		"  pyagrum.FatalError\n"
		"    If vals is a vector of 0s\n"
		"  pyagrum.UndefinedElement\n"
		"    If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_chgEvidence", _wrap_LazyPropagation_chgEvidence, METH_VARARGS, "\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 : int|str\n"
		"  a node value or the label of the node value\n"
		"vals : List[float]\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"pyagrum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"pyagrum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"pyagrum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"pyagrum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_hasEvidence", _wrap_LazyPropagation_hasEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_eraseAllEvidence", _wrap_LazyPropagation_eraseAllEvidence, METH_O, "\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "LazyPropagation_eraseEvidence", _wrap_LazyPropagation_eraseEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_hasHardEvidence", _wrap_LazyPropagation_hasHardEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_hasSoftEvidence", _wrap_LazyPropagation_hasSoftEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_nbrEvidence", _wrap_LazyPropagation_nbrEvidence, METH_O, "\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "LazyPropagation_addTarget", _wrap_LazyPropagation_addTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "LazyPropagation_eraseTarget", _wrap_LazyPropagation_eraseTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_isTarget", _wrap_LazyPropagation_isTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_nbrTargets", _wrap_LazyPropagation_nbrTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "LazyPropagation_H", _wrap_LazyPropagation_H, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "LazyPropagation_BN", _wrap_LazyPropagation_BN, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.UndefinedElement\n"
		"    If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "LazyPropagation_posterior", _wrap_LazyPropagation_posterior, METH_VARARGS, "\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.Tensor\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LazyPropagation_eraseAllJointTargets", _wrap_LazyPropagation_eraseAllJointTargets, METH_O, "\n"
		"\n"
		"Clear all previously defined joint targets.\n"
		"\n"
		""},
	 { "LazyPropagation_eraseAllMarginalTargets", _wrap_LazyPropagation_eraseAllMarginalTargets, METH_O, "\n"
		"\n"
		"Clear all the previously defined marginal targets.\n"
		"\n"
		""},
	 { "LazyPropagation_nbrJointTargets", _wrap_LazyPropagation_nbrJointTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of joint targets\n"
		"\n"
		""},
	 { "LazyPropagation_setNumberOfThreads", _wrap_LazyPropagation_setNumberOfThreads, METH_VARARGS, "\n"
		"\n"
		"If the argument nb is different from 0, this number of threads will be used during inferences, hence overriding aGrUM's default number of threads.\n"
		"If, on the contrary, nb is equal to 0, the parallelized inference engine will comply with aGrUM's default number of threads.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nb : int\n"
		"	the number of threads to be used by ShaferShenoyMRFInference\n"
		"\n"
		""},
	 { "LazyPropagation_getNumberOfThreads", _wrap_LazyPropagation_getNumberOfThreads, METH_O, "\n"
		"\n"
		"returns the number of threads used by LazyPropagation during inferences.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of threads used by LazyPropagation during inferences\n"
		"\n"
		""},
	 { "LazyPropagation_isGumNumberOfThreadsOverriden", _wrap_LazyPropagation_isGumNumberOfThreadsOverriden, METH_O, "\n"
		"\n"
		"Indicates whether LazyPropagation currently overrides aGrUM's default number of threads (see method setNumberOfThreads).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	A Boolean indicating whether LazyPropagation currently overrides aGrUM's default number of threads\n"
		"\n"
		""},
	 { "LazyPropagation_setMaxMemory", _wrap_LazyPropagation_setMaxMemory, METH_VARARGS, "\n"
		"\n"
		"sets an upper bound on the memory consumption admissible\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"gigabytes: float\n"
		"  this upper bound in gigabytes.\n"
		"\n"
		""},
	 { "LazyPropagation_setEvidence", _wrap_LazyPropagation_setEvidence, METH_VARARGS, NULL},
	 { "LazyPropagation_updateEvidence", _wrap_LazyPropagation_updateEvidence, METH_VARARGS, NULL},
	 { "LazyPropagation_setTargets", _wrap_LazyPropagation_setTargets, METH_VARARGS, NULL},
	 { "LazyPropagation_hardEvidenceNodes", _wrap_LazyPropagation_hardEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "LazyPropagation_softEvidenceNodes", _wrap_LazyPropagation_softEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "LazyPropagation_targets", _wrap_LazyPropagation_targets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "LazyPropagation_evidenceImpact", _wrap_LazyPropagation_evidenceImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor 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 Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(targets|evs)\n"
		"\n"
		""},
	 { "LazyPropagation_jointMutualInformation", _wrap_LazyPropagation_jointMutualInformation, METH_VARARGS, NULL},
	 { "LazyPropagation_evidenceJointImpact", _wrap_LazyPropagation_evidenceJointImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor for P(joint targets|evs) (for all instanciation of targets and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"targets : List[int|str]\n"
		"  a list of node Ids or node names\n"
		"evs : Set[int|str]\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(target|evs)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.Exception\n"
		"  If some evidene entered into the Bayes net are incompatible (their joint proba = 0)\n"
		"\n"
		""},
	 { "LazyPropagation_jointPosterior", _wrap_LazyPropagation_jointPosterior, METH_VARARGS, "\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 by the Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a const ref to the posterior joint probability of the set of nodes.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LazyPropagation_addJointTarget", _wrap_LazyPropagation_addJointTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If some node(s) do not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_eraseJointTarget", _wrap_LazyPropagation_eraseJointTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_isJointTarget", _wrap_LazyPropagation_isJointTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_jointTargets", _wrap_LazyPropagation_jointTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of target sets\n"
		"\n"
		""},
	 { "LazyPropagation_swigregister", LazyPropagation_swigregister, METH_O, NULL},
	 { "LazyPropagation_swiginit", LazyPropagation_swiginit, METH_VARARGS, NULL},
	 { "new_ShaferShenoyInference", _wrap_new_ShaferShenoyInference, METH_VARARGS, NULL},
	 { "delete_ShaferShenoyInference", _wrap_delete_ShaferShenoyInference, METH_O, NULL},
	 { "ShaferShenoyInference_setTriangulation", _wrap_ShaferShenoyInference_setTriangulation, METH_VARARGS, NULL},
	 { "ShaferShenoyInference_setRelevantTensorsFinderType", _wrap_ShaferShenoyInference_setRelevantTensorsFinderType, METH_VARARGS, "\n"
		"\n"
		"sets how we determine the relevant tensors to combine\n"
		"\n"
		"When a clique sends a message to a separator, it first constitute the set of the tensors it contains and of the tensors contained in the messages it received. If RelevantTensorsFinderType = FIND_ALL, all these tensors are combined and projected to produce the message sent to the separator. If RelevantTensorsFinderType = DSEP_BAYESBALL_NODES, then only the set of tensors 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_TENSORS\n"
		"3 = DSEP_KOLLER_FRIEDMAN_2009\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type : int\n"
		"  the finder type\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If type is not implemented\n"
		"\n"
		""},
	 { "ShaferShenoyInference_setFindBarrenNodesType", _wrap_ShaferShenoyInference_setFindBarrenNodesType, METH_VARARGS, "\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"
		"pyagrum.InvalidArgument\n"
		"  If type is not implemented\n"
		"\n"
		""},
	 { "ShaferShenoyInference_joinTree", _wrap_ShaferShenoyInference_joinTree, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CliqueGraph\n"
		"  the current join tree used\n"
		"\n"
		""},
	 { "ShaferShenoyInference_junctionTree", _wrap_ShaferShenoyInference_junctionTree, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CliqueGraph\n"
		"  the current junction tree\n"
		"\n"
		""},
	 { "ShaferShenoyInference_evidenceProbability", _wrap_ShaferShenoyInference_evidenceProbability, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the probability of evidence\n"
		"\n"
		""},
	 { "ShaferShenoyInference_makeInference", _wrap_ShaferShenoyInference_makeInference, METH_O, "\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_addEvidence", _wrap_ShaferShenoyInference_addEvidence, METH_VARARGS, "\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"
		"  pyagrum.InvalidArgument\n"
		"    If the node already has an evidence\n"
		"  pyagrum.InvalidArgument\n"
		"    If val is not a value for the node\n"
		"  pyagrum.InvalidArgument\n"
		"    If the size of vals is different from the domain side of the node\n"
		"  pyagrum.FatalError\n"
		"    If vals is a vector of 0s\n"
		"  pyagrum.UndefinedElement\n"
		"    If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_chgEvidence", _wrap_ShaferShenoyInference_chgEvidence, METH_VARARGS, "\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 : int|str\n"
		"  a node value or the label of the node value\n"
		"vals : List[float]\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"pyagrum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"pyagrum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"pyagrum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"pyagrum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_hasEvidence", _wrap_ShaferShenoyInference_hasEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_eraseAllEvidence", _wrap_ShaferShenoyInference_eraseAllEvidence, METH_O, "\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "ShaferShenoyInference_eraseEvidence", _wrap_ShaferShenoyInference_eraseEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_hasHardEvidence", _wrap_ShaferShenoyInference_hasHardEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_hasSoftEvidence", _wrap_ShaferShenoyInference_hasSoftEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_nbrEvidence", _wrap_ShaferShenoyInference_nbrEvidence, METH_O, "\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "ShaferShenoyInference_addTarget", _wrap_ShaferShenoyInference_addTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "ShaferShenoyInference_eraseTarget", _wrap_ShaferShenoyInference_eraseTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_isTarget", _wrap_ShaferShenoyInference_isTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_nbrTargets", _wrap_ShaferShenoyInference_nbrTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "ShaferShenoyInference_H", _wrap_ShaferShenoyInference_H, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "ShaferShenoyInference_BN", _wrap_ShaferShenoyInference_BN, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.UndefinedElement\n"
		"    If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "ShaferShenoyInference_posterior", _wrap_ShaferShenoyInference_posterior, METH_VARARGS, "\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.Tensor\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "ShaferShenoyInference_eraseAllJointTargets", _wrap_ShaferShenoyInference_eraseAllJointTargets, METH_O, "\n"
		"\n"
		"Clear all previously defined joint targets.\n"
		"\n"
		""},
	 { "ShaferShenoyInference_eraseAllMarginalTargets", _wrap_ShaferShenoyInference_eraseAllMarginalTargets, METH_O, "\n"
		"\n"
		"Clear all the previously defined marginal targets.\n"
		"\n"
		""},
	 { "ShaferShenoyInference_nbrJointTargets", _wrap_ShaferShenoyInference_nbrJointTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of joint targets\n"
		"\n"
		""},
	 { "ShaferShenoyInference_setNumberOfThreads", _wrap_ShaferShenoyInference_setNumberOfThreads, METH_VARARGS, "\n"
		"\n"
		"If the argument nb is different from 0, this number of threads will be used during inferences, hence overriding aGrUM's default number of threads.\n"
		"If, on the contrary, nb is equal to 0, the parallelized inference engine will comply with aGrUM's default number of threads.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nb : int\n"
		"	the number of threads to be used by ShaferShenoyMRFInference\n"
		"\n"
		""},
	 { "ShaferShenoyInference_getNumberOfThreads", _wrap_ShaferShenoyInference_getNumberOfThreads, METH_O, "\n"
		"\n"
		"returns the number of threads used by LazyPropagation during inferences.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of threads used by LazyPropagation during inferences\n"
		"\n"
		""},
	 { "ShaferShenoyInference_isGumNumberOfThreadsOverriden", _wrap_ShaferShenoyInference_isGumNumberOfThreadsOverriden, METH_O, "\n"
		"\n"
		"Indicates whether LazyPropagation currently overrides aGrUM's default number of threads (see method setNumberOfThreads).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	A Boolean indicating whether LazyPropagation currently overrides aGrUM's default number of threads\n"
		"\n"
		""},
	 { "ShaferShenoyInference_setMaxMemory", _wrap_ShaferShenoyInference_setMaxMemory, METH_VARARGS, "\n"
		"\n"
		"sets an upper bound on the memory consumption admissible\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"gigabytes: float\n"
		"  this upper bound in gigabytes.\n"
		"\n"
		""},
	 { "ShaferShenoyInference_setEvidence", _wrap_ShaferShenoyInference_setEvidence, METH_VARARGS, NULL},
	 { "ShaferShenoyInference_updateEvidence", _wrap_ShaferShenoyInference_updateEvidence, METH_VARARGS, NULL},
	 { "ShaferShenoyInference_setTargets", _wrap_ShaferShenoyInference_setTargets, METH_VARARGS, NULL},
	 { "ShaferShenoyInference_hardEvidenceNodes", _wrap_ShaferShenoyInference_hardEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "ShaferShenoyInference_softEvidenceNodes", _wrap_ShaferShenoyInference_softEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "ShaferShenoyInference_targets", _wrap_ShaferShenoyInference_targets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "ShaferShenoyInference_evidenceImpact", _wrap_ShaferShenoyInference_evidenceImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor 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 Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(targets|evs)\n"
		"\n"
		""},
	 { "ShaferShenoyInference_jointMutualInformation", _wrap_ShaferShenoyInference_jointMutualInformation, METH_VARARGS, NULL},
	 { "ShaferShenoyInference_evidenceJointImpact", _wrap_ShaferShenoyInference_evidenceJointImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor for P(joint targets|evs) (for all instanciation of targets and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"targets : List[int|str]\n"
		"  a list of node Ids or node names\n"
		"evs : Set[int|str]\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(target|evs)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.Exception\n"
		"  If some evidene entered into the Bayes net are incompatible (their joint proba = 0)\n"
		"\n"
		""},
	 { "ShaferShenoyInference_jointPosterior", _wrap_ShaferShenoyInference_jointPosterior, METH_VARARGS, "\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 by the Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a const ref to the posterior joint probability of the set of nodes.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "ShaferShenoyInference_addJointTarget", _wrap_ShaferShenoyInference_addJointTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If some node(s) do not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_eraseJointTarget", _wrap_ShaferShenoyInference_eraseJointTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_isJointTarget", _wrap_ShaferShenoyInference_isJointTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_jointTargets", _wrap_ShaferShenoyInference_jointTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of target sets\n"
		"\n"
		""},
	 { "ShaferShenoyInference_swigregister", ShaferShenoyInference_swigregister, METH_O, NULL},
	 { "ShaferShenoyInference_swiginit", ShaferShenoyInference_swiginit, METH_VARARGS, NULL},
	 { "new_VariableElimination", _wrap_new_VariableElimination, METH_VARARGS, NULL},
	 { "delete_VariableElimination", _wrap_delete_VariableElimination, METH_O, NULL},
	 { "VariableElimination_setTriangulation", _wrap_VariableElimination_setTriangulation, METH_VARARGS, NULL},
	 { "VariableElimination_setRelevantTensorsFinderType", _wrap_VariableElimination_setRelevantTensorsFinderType, METH_VARARGS, "\n"
		"\n"
		"sets how we determine the relevant tensors to combine\n"
		"\n"
		"When a clique sends a message to a separator, it first constitute the set of the tensors it contains and of the tensors contained in the messages it received. If RelevantTensorsFinderType = FIND_ALL, all these tensors are combined and projected to produce the message sent to the separator. If RelevantTensorsFinderType = DSEP_BAYESBALL_NODES, then only the set of tensors 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_TENSORS\n"
		"3 = DSEP_KOLLER_FRIEDMAN_2009\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type : int\n"
		"  the finder type\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If type is not implemented\n"
		"\n"
		""},
	 { "VariableElimination_setFindBarrenNodesType", _wrap_VariableElimination_setFindBarrenNodesType, METH_VARARGS, "\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"
		"pyagrum.InvalidArgument\n"
		"  If type is not implemented\n"
		"\n"
		""},
	 { "VariableElimination_junctionTree", _wrap_VariableElimination_junctionTree, METH_VARARGS, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CliqueGraph\n"
		"  the current junction tree\n"
		"\n"
		""},
	 { "VariableElimination_makeInference", _wrap_VariableElimination_makeInference, METH_O, "\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"
		"\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.Tensor\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "VariableElimination_addEvidence", _wrap_VariableElimination_addEvidence, METH_VARARGS, "\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"
		"  pyagrum.InvalidArgument\n"
		"    If the node already has an evidence\n"
		"  pyagrum.InvalidArgument\n"
		"    If val is not a value for the node\n"
		"  pyagrum.InvalidArgument\n"
		"    If the size of vals is different from the domain side of the node\n"
		"  pyagrum.FatalError\n"
		"    If vals is a vector of 0s\n"
		"  pyagrum.UndefinedElement\n"
		"    If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_chgEvidence", _wrap_VariableElimination_chgEvidence, METH_VARARGS, "\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 : int|str\n"
		"  a node value or the label of the node value\n"
		"vals : List[float]\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"pyagrum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"pyagrum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"pyagrum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"pyagrum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_hasEvidence", _wrap_VariableElimination_hasEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_eraseAllEvidence", _wrap_VariableElimination_eraseAllEvidence, METH_O, "\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "VariableElimination_eraseEvidence", _wrap_VariableElimination_eraseEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_hasHardEvidence", _wrap_VariableElimination_hasHardEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_hasSoftEvidence", _wrap_VariableElimination_hasSoftEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_nbrEvidence", _wrap_VariableElimination_nbrEvidence, METH_O, "\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "VariableElimination_addTarget", _wrap_VariableElimination_addTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "VariableElimination_eraseTarget", _wrap_VariableElimination_eraseTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_isTarget", _wrap_VariableElimination_isTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_nbrTargets", _wrap_VariableElimination_nbrTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "VariableElimination_H", _wrap_VariableElimination_H, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "VariableElimination_BN", _wrap_VariableElimination_BN, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.UndefinedElement\n"
		"    If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "VariableElimination_setNumberOfThreads", _wrap_VariableElimination_setNumberOfThreads, METH_VARARGS, "\n"
		"\n"
		"If the argument nb is different from 0, this number of threads will be used during inferences, hence overriding aGrUM's default number of threads.\n"
		"If, on the contrary, nb is equal to 0, the parallelized inference engine will comply with aGrUM's default number of threads.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nb : int\n"
		"	the number of threads to be used by ShaferShenoyMRFInference\n"
		"\n"
		""},
	 { "VariableElimination_getNumberOfThreads", _wrap_VariableElimination_getNumberOfThreads, METH_O, "\n"
		"\n"
		"returns the number of threads used by LazyPropagation during inferences.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of threads used by LazyPropagation during inferences\n"
		"\n"
		""},
	 { "VariableElimination_isGumNumberOfThreadsOverriden", _wrap_VariableElimination_isGumNumberOfThreadsOverriden, METH_O, "\n"
		"\n"
		"Indicates whether LazyPropagation currently overrides aGrUM's default number of threads (see method setNumberOfThreads).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	A Boolean indicating whether LazyPropagation currently overrides aGrUM's default number of threads\n"
		"\n"
		""},
	 { "VariableElimination_setMaxMemory", _wrap_VariableElimination_setMaxMemory, METH_VARARGS, "\n"
		"\n"
		"sets an upper bound on the memory consumption admissible\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"gigabytes: float\n"
		"  this upper bound in gigabytes.\n"
		"\n"
		""},
	 { "VariableElimination_setEvidence", _wrap_VariableElimination_setEvidence, METH_VARARGS, NULL},
	 { "VariableElimination_updateEvidence", _wrap_VariableElimination_updateEvidence, METH_VARARGS, NULL},
	 { "VariableElimination_setTargets", _wrap_VariableElimination_setTargets, METH_VARARGS, NULL},
	 { "VariableElimination_hardEvidenceNodes", _wrap_VariableElimination_hardEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "VariableElimination_softEvidenceNodes", _wrap_VariableElimination_softEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "VariableElimination_targets", _wrap_VariableElimination_targets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "VariableElimination_evidenceImpact", _wrap_VariableElimination_evidenceImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor 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 Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(targets|evs)\n"
		"\n"
		""},
	 { "VariableElimination_jointMutualInformation", _wrap_VariableElimination_jointMutualInformation, METH_VARARGS, NULL},
	 { "VariableElimination_evidenceJointImpact", _wrap_VariableElimination_evidenceJointImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor for P(joint targets|evs) (for all instanciation of targets and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"targets : List[int|str]\n"
		"  a list of node Ids or node names\n"
		"evs : Set[int|str]\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(target|evs)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.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"
		"\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 by the Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a const ref to the posterior joint probability of the set of nodes.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "VariableElimination_addJointTarget", _wrap_VariableElimination_addJointTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If some node(s) do not belong to the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_eraseJointTarget", _wrap_VariableElimination_eraseJointTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_isJointTarget", _wrap_VariableElimination_isJointTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_jointTargets", _wrap_VariableElimination_jointTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of target sets\n"
		"\n"
		""},
	 { "VariableElimination_swigregister", VariableElimination_swigregister, METH_O, NULL},
	 { "VariableElimination_swiginit", VariableElimination_swiginit, METH_VARARGS, NULL},
	 { "new_GibbsSampling", _wrap_new_GibbsSampling, METH_O, NULL},
	 { "delete_GibbsSampling", _wrap_delete_GibbsSampling, METH_O, NULL},
	 { "GibbsSampling_setBurnIn", _wrap_GibbsSampling_setBurnIn, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  size of burn in on number of iteration\n"
		"\n"
		""},
	 { "GibbsSampling_setVerbosity", _wrap_GibbsSampling_setVerbosity, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "GibbsSampling_setEpsilon", _wrap_GibbsSampling_setEpsilon, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : float\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "GibbsSampling_setMinEpsilonRate", _wrap_GibbsSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "GibbsSampling_setMaxIter", _wrap_GibbsSampling_setMaxIter, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "GibbsSampling_setMaxTime", _wrap_GibbsSampling_setMaxTime, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : float\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "GibbsSampling_setPeriodSize", _wrap_GibbsSampling_setPeriodSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "GibbsSampling_verbosity", _wrap_GibbsSampling_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "GibbsSampling_epsilon", _wrap_GibbsSampling_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "GibbsSampling_minEpsilonRate", _wrap_GibbsSampling_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "GibbsSampling_maxIter", _wrap_GibbsSampling_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "GibbsSampling_maxTime", _wrap_GibbsSampling_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "GibbsSampling_periodSize", _wrap_GibbsSampling_periodSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "GibbsSampling_nbrIterations", _wrap_GibbsSampling_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "GibbsSampling_currentTime", _wrap_GibbsSampling_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	get the current running time in second (float)\n"
		"\n"
		""},
	 { "GibbsSampling_messageApproximationScheme", _wrap_GibbsSampling_messageApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "GibbsSampling_history", _wrap_GibbsSampling_history, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "GibbsSampling__asIApproximationSchemeConfiguration", _wrap_GibbsSampling__asIApproximationSchemeConfiguration, METH_O, NULL},
	 { "GibbsSampling_makeInference", _wrap_GibbsSampling_makeInference, METH_O, "\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"
		"\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.Tensor\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "GibbsSampling_addEvidence", _wrap_GibbsSampling_addEvidence, METH_VARARGS, "\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"
		"  pyagrum.InvalidArgument\n"
		"    If the node already has an evidence\n"
		"  pyagrum.InvalidArgument\n"
		"    If val is not a value for the node\n"
		"  pyagrum.InvalidArgument\n"
		"    If the size of vals is different from the domain side of the node\n"
		"  pyagrum.FatalError\n"
		"    If vals is a vector of 0s\n"
		"  pyagrum.UndefinedElement\n"
		"    If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_chgEvidence", _wrap_GibbsSampling_chgEvidence, METH_VARARGS, "\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 : int|str\n"
		"  a node value or the label of the node value\n"
		"vals : List[float]\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"pyagrum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"pyagrum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"pyagrum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"pyagrum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_hasEvidence", _wrap_GibbsSampling_hasEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_eraseAllEvidence", _wrap_GibbsSampling_eraseAllEvidence, METH_O, "\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "GibbsSampling_eraseEvidence", _wrap_GibbsSampling_eraseEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_hasHardEvidence", _wrap_GibbsSampling_hasHardEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_hasSoftEvidence", _wrap_GibbsSampling_hasSoftEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_nbrEvidence", _wrap_GibbsSampling_nbrEvidence, METH_O, "\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "GibbsSampling_addTarget", _wrap_GibbsSampling_addTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "GibbsSampling_eraseTarget", _wrap_GibbsSampling_eraseTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_isTarget", _wrap_GibbsSampling_isTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_nbrTargets", _wrap_GibbsSampling_nbrTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "GibbsSampling_H", _wrap_GibbsSampling_H, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "GibbsSampling_BN", _wrap_GibbsSampling_BN, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.UndefinedElement\n"
		"    If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "GibbsSampling_currentPosterior", _wrap_GibbsSampling_currentPosterior, METH_VARARGS, "\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.Tensor\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of variable drawn at each iteration\n"
		"\n"
		""},
	 { "GibbsSampling_setNbrDrawnVar", _wrap_GibbsSampling_setNbrDrawnVar, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variables are drawn at random\n"
		"\n"
		""},
	 { "GibbsSampling_setDrawnAtRandom", _wrap_GibbsSampling_setDrawnAtRandom, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"_atRandom : bool\n"
		"  indicates if variables should be drawn at random\n"
		"\n"
		""},
	 { "GibbsSampling_setEvidence", _wrap_GibbsSampling_setEvidence, METH_VARARGS, NULL},
	 { "GibbsSampling_updateEvidence", _wrap_GibbsSampling_updateEvidence, METH_VARARGS, NULL},
	 { "GibbsSampling_setTargets", _wrap_GibbsSampling_setTargets, METH_VARARGS, NULL},
	 { "GibbsSampling_hardEvidenceNodes", _wrap_GibbsSampling_hardEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "GibbsSampling_softEvidenceNodes", _wrap_GibbsSampling_softEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "GibbsSampling_targets", _wrap_GibbsSampling_targets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "GibbsSampling_evidenceImpact", _wrap_GibbsSampling_evidenceImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor 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 Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(targets|evs)\n"
		"\n"
		""},
	 { "GibbsSampling_swigregister", GibbsSampling_swigregister, METH_O, NULL},
	 { "GibbsSampling_swiginit", GibbsSampling_swiginit, METH_VARARGS, NULL},
	 { "new_ImportanceSampling", _wrap_new_ImportanceSampling, METH_O, NULL},
	 { "delete_ImportanceSampling", _wrap_delete_ImportanceSampling, METH_O, NULL},
	 { "ImportanceSampling_setVerbosity", _wrap_ImportanceSampling_setVerbosity, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "ImportanceSampling_setEpsilon", _wrap_ImportanceSampling_setEpsilon, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : float\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "ImportanceSampling_setMinEpsilonRate", _wrap_ImportanceSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "ImportanceSampling_setMaxIter", _wrap_ImportanceSampling_setMaxIter, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "ImportanceSampling_setMaxTime", _wrap_ImportanceSampling_setMaxTime, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : float\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "ImportanceSampling_setPeriodSize", _wrap_ImportanceSampling_setPeriodSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "ImportanceSampling_verbosity", _wrap_ImportanceSampling_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "ImportanceSampling_epsilon", _wrap_ImportanceSampling_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "ImportanceSampling_minEpsilonRate", _wrap_ImportanceSampling_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "ImportanceSampling_maxIter", _wrap_ImportanceSampling_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "ImportanceSampling_maxTime", _wrap_ImportanceSampling_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "ImportanceSampling_periodSize", _wrap_ImportanceSampling_periodSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "ImportanceSampling_nbrIterations", _wrap_ImportanceSampling_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "ImportanceSampling_currentTime", _wrap_ImportanceSampling_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	get the current running time in second (float)\n"
		"\n"
		""},
	 { "ImportanceSampling_messageApproximationScheme", _wrap_ImportanceSampling_messageApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "ImportanceSampling_history", _wrap_ImportanceSampling_history, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "ImportanceSampling__asIApproximationSchemeConfiguration", _wrap_ImportanceSampling__asIApproximationSchemeConfiguration, METH_O, NULL},
	 { "ImportanceSampling_makeInference", _wrap_ImportanceSampling_makeInference, METH_O, "\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"
		"\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.Tensor\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "ImportanceSampling_addEvidence", _wrap_ImportanceSampling_addEvidence, METH_VARARGS, "\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"
		"  pyagrum.InvalidArgument\n"
		"    If the node already has an evidence\n"
		"  pyagrum.InvalidArgument\n"
		"    If val is not a value for the node\n"
		"  pyagrum.InvalidArgument\n"
		"    If the size of vals is different from the domain side of the node\n"
		"  pyagrum.FatalError\n"
		"    If vals is a vector of 0s\n"
		"  pyagrum.UndefinedElement\n"
		"    If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_chgEvidence", _wrap_ImportanceSampling_chgEvidence, METH_VARARGS, "\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 : int|str\n"
		"  a node value or the label of the node value\n"
		"vals : List[float]\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"pyagrum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"pyagrum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"pyagrum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"pyagrum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_hasEvidence", _wrap_ImportanceSampling_hasEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_eraseAllEvidence", _wrap_ImportanceSampling_eraseAllEvidence, METH_O, "\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "ImportanceSampling_eraseEvidence", _wrap_ImportanceSampling_eraseEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_hasHardEvidence", _wrap_ImportanceSampling_hasHardEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_hasSoftEvidence", _wrap_ImportanceSampling_hasSoftEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_nbrEvidence", _wrap_ImportanceSampling_nbrEvidence, METH_O, "\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "ImportanceSampling_addTarget", _wrap_ImportanceSampling_addTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "ImportanceSampling_eraseTarget", _wrap_ImportanceSampling_eraseTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_isTarget", _wrap_ImportanceSampling_isTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_nbrTargets", _wrap_ImportanceSampling_nbrTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "ImportanceSampling_H", _wrap_ImportanceSampling_H, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "ImportanceSampling_BN", _wrap_ImportanceSampling_BN, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.UndefinedElement\n"
		"    If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "ImportanceSampling_currentPosterior", _wrap_ImportanceSampling_currentPosterior, METH_VARARGS, "\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.Tensor\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_setEvidence", _wrap_ImportanceSampling_setEvidence, METH_VARARGS, NULL},
	 { "ImportanceSampling_updateEvidence", _wrap_ImportanceSampling_updateEvidence, METH_VARARGS, NULL},
	 { "ImportanceSampling_setTargets", _wrap_ImportanceSampling_setTargets, METH_VARARGS, NULL},
	 { "ImportanceSampling_hardEvidenceNodes", _wrap_ImportanceSampling_hardEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "ImportanceSampling_softEvidenceNodes", _wrap_ImportanceSampling_softEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "ImportanceSampling_targets", _wrap_ImportanceSampling_targets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "ImportanceSampling_evidenceImpact", _wrap_ImportanceSampling_evidenceImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor 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 Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(targets|evs)\n"
		"\n"
		""},
	 { "ImportanceSampling_swigregister", ImportanceSampling_swigregister, METH_O, NULL},
	 { "ImportanceSampling_swiginit", ImportanceSampling_swiginit, METH_VARARGS, NULL},
	 { "new_WeightedSampling", _wrap_new_WeightedSampling, METH_O, NULL},
	 { "delete_WeightedSampling", _wrap_delete_WeightedSampling, METH_O, NULL},
	 { "WeightedSampling_setVerbosity", _wrap_WeightedSampling_setVerbosity, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "WeightedSampling_setEpsilon", _wrap_WeightedSampling_setEpsilon, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : float\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "WeightedSampling_setMinEpsilonRate", _wrap_WeightedSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "WeightedSampling_setMaxIter", _wrap_WeightedSampling_setMaxIter, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "WeightedSampling_setMaxTime", _wrap_WeightedSampling_setMaxTime, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : float\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "WeightedSampling_setPeriodSize", _wrap_WeightedSampling_setPeriodSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "WeightedSampling_verbosity", _wrap_WeightedSampling_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "WeightedSampling_epsilon", _wrap_WeightedSampling_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "WeightedSampling_minEpsilonRate", _wrap_WeightedSampling_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "WeightedSampling_maxIter", _wrap_WeightedSampling_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "WeightedSampling_maxTime", _wrap_WeightedSampling_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "WeightedSampling_periodSize", _wrap_WeightedSampling_periodSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "WeightedSampling_nbrIterations", _wrap_WeightedSampling_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "WeightedSampling_currentTime", _wrap_WeightedSampling_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	get the current running time in second (float)\n"
		"\n"
		""},
	 { "WeightedSampling_messageApproximationScheme", _wrap_WeightedSampling_messageApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "WeightedSampling_history", _wrap_WeightedSampling_history, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "WeightedSampling__asIApproximationSchemeConfiguration", _wrap_WeightedSampling__asIApproximationSchemeConfiguration, METH_O, NULL},
	 { "WeightedSampling_makeInference", _wrap_WeightedSampling_makeInference, METH_O, "\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"
		"\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.Tensor\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "WeightedSampling_addEvidence", _wrap_WeightedSampling_addEvidence, METH_VARARGS, "\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"
		"  pyagrum.InvalidArgument\n"
		"    If the node already has an evidence\n"
		"  pyagrum.InvalidArgument\n"
		"    If val is not a value for the node\n"
		"  pyagrum.InvalidArgument\n"
		"    If the size of vals is different from the domain side of the node\n"
		"  pyagrum.FatalError\n"
		"    If vals is a vector of 0s\n"
		"  pyagrum.UndefinedElement\n"
		"    If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_chgEvidence", _wrap_WeightedSampling_chgEvidence, METH_VARARGS, "\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 : int|str\n"
		"  a node value or the label of the node value\n"
		"vals : List[float]\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"pyagrum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"pyagrum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"pyagrum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"pyagrum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_hasEvidence", _wrap_WeightedSampling_hasEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_eraseAllEvidence", _wrap_WeightedSampling_eraseAllEvidence, METH_O, "\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "WeightedSampling_eraseEvidence", _wrap_WeightedSampling_eraseEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_hasHardEvidence", _wrap_WeightedSampling_hasHardEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_hasSoftEvidence", _wrap_WeightedSampling_hasSoftEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_nbrEvidence", _wrap_WeightedSampling_nbrEvidence, METH_O, "\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "WeightedSampling_addTarget", _wrap_WeightedSampling_addTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "WeightedSampling_eraseTarget", _wrap_WeightedSampling_eraseTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_isTarget", _wrap_WeightedSampling_isTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_nbrTargets", _wrap_WeightedSampling_nbrTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "WeightedSampling_H", _wrap_WeightedSampling_H, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "WeightedSampling_BN", _wrap_WeightedSampling_BN, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.UndefinedElement\n"
		"    If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "WeightedSampling_currentPosterior", _wrap_WeightedSampling_currentPosterior, METH_VARARGS, "\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.Tensor\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_setEvidence", _wrap_WeightedSampling_setEvidence, METH_VARARGS, NULL},
	 { "WeightedSampling_updateEvidence", _wrap_WeightedSampling_updateEvidence, METH_VARARGS, NULL},
	 { "WeightedSampling_setTargets", _wrap_WeightedSampling_setTargets, METH_VARARGS, NULL},
	 { "WeightedSampling_hardEvidenceNodes", _wrap_WeightedSampling_hardEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "WeightedSampling_softEvidenceNodes", _wrap_WeightedSampling_softEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "WeightedSampling_targets", _wrap_WeightedSampling_targets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "WeightedSampling_evidenceImpact", _wrap_WeightedSampling_evidenceImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor 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 Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(targets|evs)\n"
		"\n"
		""},
	 { "WeightedSampling_swigregister", WeightedSampling_swigregister, METH_O, NULL},
	 { "WeightedSampling_swiginit", WeightedSampling_swiginit, METH_VARARGS, NULL},
	 { "new_MonteCarloSampling", _wrap_new_MonteCarloSampling, METH_O, NULL},
	 { "delete_MonteCarloSampling", _wrap_delete_MonteCarloSampling, METH_O, NULL},
	 { "MonteCarloSampling_setVerbosity", _wrap_MonteCarloSampling_setVerbosity, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "MonteCarloSampling_setEpsilon", _wrap_MonteCarloSampling_setEpsilon, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : float\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "MonteCarloSampling_setMinEpsilonRate", _wrap_MonteCarloSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "MonteCarloSampling_setMaxIter", _wrap_MonteCarloSampling_setMaxIter, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "MonteCarloSampling_setMaxTime", _wrap_MonteCarloSampling_setMaxTime, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : float\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "MonteCarloSampling_setPeriodSize", _wrap_MonteCarloSampling_setPeriodSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "MonteCarloSampling_verbosity", _wrap_MonteCarloSampling_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "MonteCarloSampling_epsilon", _wrap_MonteCarloSampling_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "MonteCarloSampling_minEpsilonRate", _wrap_MonteCarloSampling_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "MonteCarloSampling_maxIter", _wrap_MonteCarloSampling_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "MonteCarloSampling_maxTime", _wrap_MonteCarloSampling_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "MonteCarloSampling_periodSize", _wrap_MonteCarloSampling_periodSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "MonteCarloSampling_nbrIterations", _wrap_MonteCarloSampling_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "MonteCarloSampling_currentTime", _wrap_MonteCarloSampling_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	get the current running time in second (float)\n"
		"\n"
		""},
	 { "MonteCarloSampling_messageApproximationScheme", _wrap_MonteCarloSampling_messageApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "MonteCarloSampling_history", _wrap_MonteCarloSampling_history, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "MonteCarloSampling__asIApproximationSchemeConfiguration", _wrap_MonteCarloSampling__asIApproximationSchemeConfiguration, METH_O, NULL},
	 { "MonteCarloSampling_makeInference", _wrap_MonteCarloSampling_makeInference, METH_O, "\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"
		"\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.Tensor\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "MonteCarloSampling_addEvidence", _wrap_MonteCarloSampling_addEvidence, METH_VARARGS, "\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"
		"  pyagrum.InvalidArgument\n"
		"    If the node already has an evidence\n"
		"  pyagrum.InvalidArgument\n"
		"    If val is not a value for the node\n"
		"  pyagrum.InvalidArgument\n"
		"    If the size of vals is different from the domain side of the node\n"
		"  pyagrum.FatalError\n"
		"    If vals is a vector of 0s\n"
		"  pyagrum.UndefinedElement\n"
		"    If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_chgEvidence", _wrap_MonteCarloSampling_chgEvidence, METH_VARARGS, "\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 : int|str\n"
		"  a node value or the label of the node value\n"
		"vals : List[float]\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"pyagrum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"pyagrum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"pyagrum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"pyagrum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_hasEvidence", _wrap_MonteCarloSampling_hasEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_eraseAllEvidence", _wrap_MonteCarloSampling_eraseAllEvidence, METH_O, "\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "MonteCarloSampling_eraseEvidence", _wrap_MonteCarloSampling_eraseEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_hasHardEvidence", _wrap_MonteCarloSampling_hasHardEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_hasSoftEvidence", _wrap_MonteCarloSampling_hasSoftEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_nbrEvidence", _wrap_MonteCarloSampling_nbrEvidence, METH_O, "\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "MonteCarloSampling_addTarget", _wrap_MonteCarloSampling_addTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "MonteCarloSampling_eraseTarget", _wrap_MonteCarloSampling_eraseTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_isTarget", _wrap_MonteCarloSampling_isTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_nbrTargets", _wrap_MonteCarloSampling_nbrTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "MonteCarloSampling_H", _wrap_MonteCarloSampling_H, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "MonteCarloSampling_BN", _wrap_MonteCarloSampling_BN, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.UndefinedElement\n"
		"    If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "MonteCarloSampling_currentPosterior", _wrap_MonteCarloSampling_currentPosterior, METH_VARARGS, "\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.Tensor\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_setEvidence", _wrap_MonteCarloSampling_setEvidence, METH_VARARGS, NULL},
	 { "MonteCarloSampling_updateEvidence", _wrap_MonteCarloSampling_updateEvidence, METH_VARARGS, NULL},
	 { "MonteCarloSampling_setTargets", _wrap_MonteCarloSampling_setTargets, METH_VARARGS, NULL},
	 { "MonteCarloSampling_hardEvidenceNodes", _wrap_MonteCarloSampling_hardEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "MonteCarloSampling_softEvidenceNodes", _wrap_MonteCarloSampling_softEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "MonteCarloSampling_targets", _wrap_MonteCarloSampling_targets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "MonteCarloSampling_evidenceImpact", _wrap_MonteCarloSampling_evidenceImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor 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 Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(targets|evs)\n"
		"\n"
		""},
	 { "MonteCarloSampling_swigregister", MonteCarloSampling_swigregister, METH_O, NULL},
	 { "MonteCarloSampling_swiginit", MonteCarloSampling_swiginit, METH_VARARGS, NULL},
	 { "new_LoopyImportanceSampling", _wrap_new_LoopyImportanceSampling, METH_O, NULL},
	 { "delete_LoopyImportanceSampling", _wrap_delete_LoopyImportanceSampling, METH_O, NULL},
	 { "LoopyImportanceSampling_makeInference_", _wrap_LoopyImportanceSampling_makeInference_, METH_O, NULL},
	 { "LoopyImportanceSampling_setVirtualLBPSize", _wrap_LoopyImportanceSampling_setVirtualLBPSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"vlbpsize : float\n"
		"  the size of the virtual LBP\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_setVerbosity", _wrap_LoopyImportanceSampling_setVerbosity, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_setEpsilon", _wrap_LoopyImportanceSampling_setEpsilon, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : float\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_setMinEpsilonRate", _wrap_LoopyImportanceSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_setMaxIter", _wrap_LoopyImportanceSampling_setMaxIter, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_setMaxTime", _wrap_LoopyImportanceSampling_setMaxTime, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : float\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_setPeriodSize", _wrap_LoopyImportanceSampling_setPeriodSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_verbosity", _wrap_LoopyImportanceSampling_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_epsilon", _wrap_LoopyImportanceSampling_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_minEpsilonRate", _wrap_LoopyImportanceSampling_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_maxIter", _wrap_LoopyImportanceSampling_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_maxTime", _wrap_LoopyImportanceSampling_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_periodSize", _wrap_LoopyImportanceSampling_periodSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_nbrIterations", _wrap_LoopyImportanceSampling_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_currentTime", _wrap_LoopyImportanceSampling_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	get the current running time in second (float)\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_messageApproximationScheme", _wrap_LoopyImportanceSampling_messageApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_history", _wrap_LoopyImportanceSampling_history, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "LoopyImportanceSampling__asIApproximationSchemeConfiguration", _wrap_LoopyImportanceSampling__asIApproximationSchemeConfiguration, METH_O, NULL},
	 { "LoopyImportanceSampling_makeInference", _wrap_LoopyImportanceSampling_makeInference, METH_O, "\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"
		"\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.Tensor\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_addEvidence", _wrap_LoopyImportanceSampling_addEvidence, METH_VARARGS, "\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"
		"  pyagrum.InvalidArgument\n"
		"    If the node already has an evidence\n"
		"  pyagrum.InvalidArgument\n"
		"    If val is not a value for the node\n"
		"  pyagrum.InvalidArgument\n"
		"    If the size of vals is different from the domain side of the node\n"
		"  pyagrum.FatalError\n"
		"    If vals is a vector of 0s\n"
		"  pyagrum.UndefinedElement\n"
		"    If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_chgEvidence", _wrap_LoopyImportanceSampling_chgEvidence, METH_VARARGS, "\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 : int|str\n"
		"  a node value or the label of the node value\n"
		"vals : List[float]\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"pyagrum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"pyagrum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"pyagrum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"pyagrum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_hasEvidence", _wrap_LoopyImportanceSampling_hasEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_eraseAllEvidence", _wrap_LoopyImportanceSampling_eraseAllEvidence, METH_O, "\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_eraseEvidence", _wrap_LoopyImportanceSampling_eraseEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_hasHardEvidence", _wrap_LoopyImportanceSampling_hasHardEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_hasSoftEvidence", _wrap_LoopyImportanceSampling_hasSoftEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_nbrEvidence", _wrap_LoopyImportanceSampling_nbrEvidence, METH_O, "\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_addTarget", _wrap_LoopyImportanceSampling_addTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_eraseTarget", _wrap_LoopyImportanceSampling_eraseTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_isTarget", _wrap_LoopyImportanceSampling_isTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_nbrTargets", _wrap_LoopyImportanceSampling_nbrTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_H", _wrap_LoopyImportanceSampling_H, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_BN", _wrap_LoopyImportanceSampling_BN, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.UndefinedElement\n"
		"    If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_currentPosterior", _wrap_LoopyImportanceSampling_currentPosterior, METH_VARARGS, "\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.Tensor\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_setEvidence", _wrap_LoopyImportanceSampling_setEvidence, METH_VARARGS, NULL},
	 { "LoopyImportanceSampling_updateEvidence", _wrap_LoopyImportanceSampling_updateEvidence, METH_VARARGS, NULL},
	 { "LoopyImportanceSampling_setTargets", _wrap_LoopyImportanceSampling_setTargets, METH_VARARGS, NULL},
	 { "LoopyImportanceSampling_hardEvidenceNodes", _wrap_LoopyImportanceSampling_hardEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_softEvidenceNodes", _wrap_LoopyImportanceSampling_softEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_targets", _wrap_LoopyImportanceSampling_targets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_evidenceImpact", _wrap_LoopyImportanceSampling_evidenceImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor 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 Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(targets|evs)\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_swigregister", LoopyImportanceSampling_swigregister, METH_O, NULL},
	 { "LoopyImportanceSampling_swiginit", LoopyImportanceSampling_swiginit, METH_VARARGS, NULL},
	 { "new_LoopyWeightedSampling", _wrap_new_LoopyWeightedSampling, METH_O, NULL},
	 { "delete_LoopyWeightedSampling", _wrap_delete_LoopyWeightedSampling, METH_O, NULL},
	 { "LoopyWeightedSampling_makeInference_", _wrap_LoopyWeightedSampling_makeInference_, METH_O, NULL},
	 { "LoopyWeightedSampling_setVirtualLBPSize", _wrap_LoopyWeightedSampling_setVirtualLBPSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"vlbpsize : float\n"
		"  the size of the virtual LBP\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_setVerbosity", _wrap_LoopyWeightedSampling_setVerbosity, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_setEpsilon", _wrap_LoopyWeightedSampling_setEpsilon, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : float\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_setMinEpsilonRate", _wrap_LoopyWeightedSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_setMaxIter", _wrap_LoopyWeightedSampling_setMaxIter, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_setMaxTime", _wrap_LoopyWeightedSampling_setMaxTime, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : float\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_setPeriodSize", _wrap_LoopyWeightedSampling_setPeriodSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_verbosity", _wrap_LoopyWeightedSampling_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_epsilon", _wrap_LoopyWeightedSampling_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_minEpsilonRate", _wrap_LoopyWeightedSampling_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_maxIter", _wrap_LoopyWeightedSampling_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_maxTime", _wrap_LoopyWeightedSampling_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_periodSize", _wrap_LoopyWeightedSampling_periodSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_nbrIterations", _wrap_LoopyWeightedSampling_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_currentTime", _wrap_LoopyWeightedSampling_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	get the current running time in second (float)\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_messageApproximationScheme", _wrap_LoopyWeightedSampling_messageApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_history", _wrap_LoopyWeightedSampling_history, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "LoopyWeightedSampling__asIApproximationSchemeConfiguration", _wrap_LoopyWeightedSampling__asIApproximationSchemeConfiguration, METH_O, NULL},
	 { "LoopyWeightedSampling_makeInference", _wrap_LoopyWeightedSampling_makeInference, METH_O, "\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"
		"\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.Tensor\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_addEvidence", _wrap_LoopyWeightedSampling_addEvidence, METH_VARARGS, "\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"
		"  pyagrum.InvalidArgument\n"
		"    If the node already has an evidence\n"
		"  pyagrum.InvalidArgument\n"
		"    If val is not a value for the node\n"
		"  pyagrum.InvalidArgument\n"
		"    If the size of vals is different from the domain side of the node\n"
		"  pyagrum.FatalError\n"
		"    If vals is a vector of 0s\n"
		"  pyagrum.UndefinedElement\n"
		"    If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_chgEvidence", _wrap_LoopyWeightedSampling_chgEvidence, METH_VARARGS, "\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 : int|str\n"
		"  a node value or the label of the node value\n"
		"vals : List[float]\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"pyagrum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"pyagrum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"pyagrum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"pyagrum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_hasEvidence", _wrap_LoopyWeightedSampling_hasEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_eraseAllEvidence", _wrap_LoopyWeightedSampling_eraseAllEvidence, METH_O, "\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_eraseEvidence", _wrap_LoopyWeightedSampling_eraseEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_hasHardEvidence", _wrap_LoopyWeightedSampling_hasHardEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_hasSoftEvidence", _wrap_LoopyWeightedSampling_hasSoftEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_nbrEvidence", _wrap_LoopyWeightedSampling_nbrEvidence, METH_O, "\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_addTarget", _wrap_LoopyWeightedSampling_addTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_eraseTarget", _wrap_LoopyWeightedSampling_eraseTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_isTarget", _wrap_LoopyWeightedSampling_isTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_nbrTargets", _wrap_LoopyWeightedSampling_nbrTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_H", _wrap_LoopyWeightedSampling_H, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_BN", _wrap_LoopyWeightedSampling_BN, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.UndefinedElement\n"
		"    If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_currentPosterior", _wrap_LoopyWeightedSampling_currentPosterior, METH_VARARGS, "\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.Tensor\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_setEvidence", _wrap_LoopyWeightedSampling_setEvidence, METH_VARARGS, NULL},
	 { "LoopyWeightedSampling_updateEvidence", _wrap_LoopyWeightedSampling_updateEvidence, METH_VARARGS, NULL},
	 { "LoopyWeightedSampling_setTargets", _wrap_LoopyWeightedSampling_setTargets, METH_VARARGS, NULL},
	 { "LoopyWeightedSampling_hardEvidenceNodes", _wrap_LoopyWeightedSampling_hardEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_softEvidenceNodes", _wrap_LoopyWeightedSampling_softEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_targets", _wrap_LoopyWeightedSampling_targets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_evidenceImpact", _wrap_LoopyWeightedSampling_evidenceImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor 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 Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(targets|evs)\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_swigregister", LoopyWeightedSampling_swigregister, METH_O, NULL},
	 { "LoopyWeightedSampling_swiginit", LoopyWeightedSampling_swiginit, METH_VARARGS, NULL},
	 { "new_LoopyGibbsSampling", _wrap_new_LoopyGibbsSampling, METH_O, NULL},
	 { "delete_LoopyGibbsSampling", _wrap_delete_LoopyGibbsSampling, METH_O, NULL},
	 { "LoopyGibbsSampling_makeInference_", _wrap_LoopyGibbsSampling_makeInference_, METH_O, NULL},
	 { "LoopyGibbsSampling_setVirtualLBPSize", _wrap_LoopyGibbsSampling_setVirtualLBPSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"vlbpsize : float\n"
		"  the size of the virtual LBP\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setVerbosity", _wrap_LoopyGibbsSampling_setVerbosity, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setEpsilon", _wrap_LoopyGibbsSampling_setEpsilon, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : float\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setMinEpsilonRate", _wrap_LoopyGibbsSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setMaxIter", _wrap_LoopyGibbsSampling_setMaxIter, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setMaxTime", _wrap_LoopyGibbsSampling_setMaxTime, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : float\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setPeriodSize", _wrap_LoopyGibbsSampling_setPeriodSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_verbosity", _wrap_LoopyGibbsSampling_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_epsilon", _wrap_LoopyGibbsSampling_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_minEpsilonRate", _wrap_LoopyGibbsSampling_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_maxIter", _wrap_LoopyGibbsSampling_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_maxTime", _wrap_LoopyGibbsSampling_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_periodSize", _wrap_LoopyGibbsSampling_periodSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_nbrIterations", _wrap_LoopyGibbsSampling_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_currentTime", _wrap_LoopyGibbsSampling_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	get the current running time in second (float)\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_messageApproximationScheme", _wrap_LoopyGibbsSampling_messageApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_history", _wrap_LoopyGibbsSampling_history, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "LoopyGibbsSampling__asIApproximationSchemeConfiguration", _wrap_LoopyGibbsSampling__asIApproximationSchemeConfiguration, METH_O, NULL},
	 { "LoopyGibbsSampling_makeInference", _wrap_LoopyGibbsSampling_makeInference, METH_O, "\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"
		"\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.Tensor\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_addEvidence", _wrap_LoopyGibbsSampling_addEvidence, METH_VARARGS, "\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"
		"  pyagrum.InvalidArgument\n"
		"    If the node already has an evidence\n"
		"  pyagrum.InvalidArgument\n"
		"    If val is not a value for the node\n"
		"  pyagrum.InvalidArgument\n"
		"    If the size of vals is different from the domain side of the node\n"
		"  pyagrum.FatalError\n"
		"    If vals is a vector of 0s\n"
		"  pyagrum.UndefinedElement\n"
		"    If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_chgEvidence", _wrap_LoopyGibbsSampling_chgEvidence, METH_VARARGS, "\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 : int|str\n"
		"  a node value or the label of the node value\n"
		"vals : List[float]\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"pyagrum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"pyagrum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"pyagrum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"pyagrum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_hasEvidence", _wrap_LoopyGibbsSampling_hasEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_eraseAllEvidence", _wrap_LoopyGibbsSampling_eraseAllEvidence, METH_O, "\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_eraseEvidence", _wrap_LoopyGibbsSampling_eraseEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_hasHardEvidence", _wrap_LoopyGibbsSampling_hasHardEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_hasSoftEvidence", _wrap_LoopyGibbsSampling_hasSoftEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_nbrEvidence", _wrap_LoopyGibbsSampling_nbrEvidence, METH_O, "\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_addTarget", _wrap_LoopyGibbsSampling_addTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_eraseTarget", _wrap_LoopyGibbsSampling_eraseTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_isTarget", _wrap_LoopyGibbsSampling_isTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_nbrTargets", _wrap_LoopyGibbsSampling_nbrTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_H", _wrap_LoopyGibbsSampling_H, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_BN", _wrap_LoopyGibbsSampling_BN, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.UndefinedElement\n"
		"    If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_currentPosterior", _wrap_LoopyGibbsSampling_currentPosterior, METH_VARARGS, "\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.Tensor\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of variable drawn at each iteration\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setNbrDrawnVar", _wrap_LoopyGibbsSampling_setNbrDrawnVar, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variables are drawn at random\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setDrawnAtRandom", _wrap_LoopyGibbsSampling_setDrawnAtRandom, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  size of burn in on number of iteration\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setBurnIn", _wrap_LoopyGibbsSampling_setBurnIn, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"b : int\n"
		"  size of burn in on number of iteration\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setEvidence", _wrap_LoopyGibbsSampling_setEvidence, METH_VARARGS, NULL},
	 { "LoopyGibbsSampling_updateEvidence", _wrap_LoopyGibbsSampling_updateEvidence, METH_VARARGS, NULL},
	 { "LoopyGibbsSampling_setTargets", _wrap_LoopyGibbsSampling_setTargets, METH_VARARGS, NULL},
	 { "LoopyGibbsSampling_hardEvidenceNodes", _wrap_LoopyGibbsSampling_hardEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_softEvidenceNodes", _wrap_LoopyGibbsSampling_softEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_targets", _wrap_LoopyGibbsSampling_targets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_evidenceImpact", _wrap_LoopyGibbsSampling_evidenceImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor 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 Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(targets|evs)\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_swigregister", LoopyGibbsSampling_swigregister, METH_O, NULL},
	 { "LoopyGibbsSampling_swiginit", LoopyGibbsSampling_swiginit, METH_VARARGS, NULL},
	 { "new_LoopyMonteCarloSampling", _wrap_new_LoopyMonteCarloSampling, METH_O, NULL},
	 { "delete_LoopyMonteCarloSampling", _wrap_delete_LoopyMonteCarloSampling, METH_O, NULL},
	 { "LoopyMonteCarloSampling_makeInference_", _wrap_LoopyMonteCarloSampling_makeInference_, METH_O, NULL},
	 { "LoopyMonteCarloSampling_setVirtualLBPSize", _wrap_LoopyMonteCarloSampling_setVirtualLBPSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"vlbpsize : float\n"
		"  the size of the virtual LBP\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_setVerbosity", _wrap_LoopyMonteCarloSampling_setVerbosity, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_setEpsilon", _wrap_LoopyMonteCarloSampling_setEpsilon, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : float\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_setMinEpsilonRate", _wrap_LoopyMonteCarloSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_setMaxIter", _wrap_LoopyMonteCarloSampling_setMaxIter, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_setMaxTime", _wrap_LoopyMonteCarloSampling_setMaxTime, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : float\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_setPeriodSize", _wrap_LoopyMonteCarloSampling_setPeriodSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_verbosity", _wrap_LoopyMonteCarloSampling_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_epsilon", _wrap_LoopyMonteCarloSampling_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_minEpsilonRate", _wrap_LoopyMonteCarloSampling_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_maxIter", _wrap_LoopyMonteCarloSampling_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_maxTime", _wrap_LoopyMonteCarloSampling_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_periodSize", _wrap_LoopyMonteCarloSampling_periodSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_nbrIterations", _wrap_LoopyMonteCarloSampling_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_currentTime", _wrap_LoopyMonteCarloSampling_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	get the current running time in second (float)\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_messageApproximationScheme", _wrap_LoopyMonteCarloSampling_messageApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_history", _wrap_LoopyMonteCarloSampling_history, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling__asIApproximationSchemeConfiguration", _wrap_LoopyMonteCarloSampling__asIApproximationSchemeConfiguration, METH_O, NULL},
	 { "LoopyMonteCarloSampling_makeInference", _wrap_LoopyMonteCarloSampling_makeInference, METH_O, "\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"
		"\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.Tensor\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_addEvidence", _wrap_LoopyMonteCarloSampling_addEvidence, METH_VARARGS, "\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"
		"  pyagrum.InvalidArgument\n"
		"    If the node already has an evidence\n"
		"  pyagrum.InvalidArgument\n"
		"    If val is not a value for the node\n"
		"  pyagrum.InvalidArgument\n"
		"    If the size of vals is different from the domain side of the node\n"
		"  pyagrum.FatalError\n"
		"    If vals is a vector of 0s\n"
		"  pyagrum.UndefinedElement\n"
		"    If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_chgEvidence", _wrap_LoopyMonteCarloSampling_chgEvidence, METH_VARARGS, "\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 : int|str\n"
		"  a node value or the label of the node value\n"
		"vals : List[float]\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"pyagrum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"pyagrum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"pyagrum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"pyagrum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_hasEvidence", _wrap_LoopyMonteCarloSampling_hasEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_eraseAllEvidence", _wrap_LoopyMonteCarloSampling_eraseAllEvidence, METH_O, "\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_eraseEvidence", _wrap_LoopyMonteCarloSampling_eraseEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_hasHardEvidence", _wrap_LoopyMonteCarloSampling_hasHardEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_hasSoftEvidence", _wrap_LoopyMonteCarloSampling_hasSoftEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_nbrEvidence", _wrap_LoopyMonteCarloSampling_nbrEvidence, METH_O, "\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_addTarget", _wrap_LoopyMonteCarloSampling_addTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_eraseTarget", _wrap_LoopyMonteCarloSampling_eraseTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_isTarget", _wrap_LoopyMonteCarloSampling_isTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_nbrTargets", _wrap_LoopyMonteCarloSampling_nbrTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_H", _wrap_LoopyMonteCarloSampling_H, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_BN", _wrap_LoopyMonteCarloSampling_BN, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.UndefinedElement\n"
		"    If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_currentPosterior", _wrap_LoopyMonteCarloSampling_currentPosterior, METH_VARARGS, "\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.Tensor\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_setEvidence", _wrap_LoopyMonteCarloSampling_setEvidence, METH_VARARGS, NULL},
	 { "LoopyMonteCarloSampling_updateEvidence", _wrap_LoopyMonteCarloSampling_updateEvidence, METH_VARARGS, NULL},
	 { "LoopyMonteCarloSampling_setTargets", _wrap_LoopyMonteCarloSampling_setTargets, METH_VARARGS, NULL},
	 { "LoopyMonteCarloSampling_hardEvidenceNodes", _wrap_LoopyMonteCarloSampling_hardEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_softEvidenceNodes", _wrap_LoopyMonteCarloSampling_softEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_targets", _wrap_LoopyMonteCarloSampling_targets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_evidenceImpact", _wrap_LoopyMonteCarloSampling_evidenceImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor 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 Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(targets|evs)\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_swigregister", LoopyMonteCarloSampling_swigregister, METH_O, NULL},
	 { "LoopyMonteCarloSampling_swiginit", LoopyMonteCarloSampling_swiginit, METH_VARARGS, NULL},
	 { "new_LoopyBeliefPropagation", _wrap_new_LoopyBeliefPropagation, METH_O, NULL},
	 { "delete_LoopyBeliefPropagation", _wrap_delete_LoopyBeliefPropagation, METH_O, NULL},
	 { "LoopyBeliefPropagation_setVerbosity", _wrap_LoopyBeliefPropagation_setVerbosity, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_setEpsilon", _wrap_LoopyBeliefPropagation_setEpsilon, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : float\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_setMinEpsilonRate", _wrap_LoopyBeliefPropagation_setMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_setMaxIter", _wrap_LoopyBeliefPropagation_setMaxIter, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_setMaxTime", _wrap_LoopyBeliefPropagation_setMaxTime, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : float\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_setPeriodSize", _wrap_LoopyBeliefPropagation_setPeriodSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_verbosity", _wrap_LoopyBeliefPropagation_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_epsilon", _wrap_LoopyBeliefPropagation_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_minEpsilonRate", _wrap_LoopyBeliefPropagation_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_maxIter", _wrap_LoopyBeliefPropagation_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_maxTime", _wrap_LoopyBeliefPropagation_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_periodSize", _wrap_LoopyBeliefPropagation_periodSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_nbrIterations", _wrap_LoopyBeliefPropagation_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_currentTime", _wrap_LoopyBeliefPropagation_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	get the current running time in second (float)\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_messageApproximationScheme", _wrap_LoopyBeliefPropagation_messageApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_history", _wrap_LoopyBeliefPropagation_history, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation__asIApproximationSchemeConfiguration", _wrap_LoopyBeliefPropagation__asIApproximationSchemeConfiguration, METH_O, NULL},
	 { "LoopyBeliefPropagation_makeInference", _wrap_LoopyBeliefPropagation_makeInference, METH_O, "\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"
		"\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.Tensor\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_addEvidence", _wrap_LoopyBeliefPropagation_addEvidence, METH_VARARGS, "\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"
		"  pyagrum.InvalidArgument\n"
		"    If the node already has an evidence\n"
		"  pyagrum.InvalidArgument\n"
		"    If val is not a value for the node\n"
		"  pyagrum.InvalidArgument\n"
		"    If the size of vals is different from the domain side of the node\n"
		"  pyagrum.FatalError\n"
		"    If vals is a vector of 0s\n"
		"  pyagrum.UndefinedElement\n"
		"    If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_chgEvidence", _wrap_LoopyBeliefPropagation_chgEvidence, METH_VARARGS, "\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 : int|str\n"
		"  a node value or the label of the node value\n"
		"vals : List[float]\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"pyagrum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"pyagrum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"pyagrum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"pyagrum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_hasEvidence", _wrap_LoopyBeliefPropagation_hasEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_eraseAllEvidence", _wrap_LoopyBeliefPropagation_eraseAllEvidence, METH_O, "\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_eraseEvidence", _wrap_LoopyBeliefPropagation_eraseEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_hasHardEvidence", _wrap_LoopyBeliefPropagation_hasHardEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_hasSoftEvidence", _wrap_LoopyBeliefPropagation_hasSoftEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_nbrEvidence", _wrap_LoopyBeliefPropagation_nbrEvidence, METH_O, "\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_addTarget", _wrap_LoopyBeliefPropagation_addTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_eraseTarget", _wrap_LoopyBeliefPropagation_eraseTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_isTarget", _wrap_LoopyBeliefPropagation_isTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_nbrTargets", _wrap_LoopyBeliefPropagation_nbrTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_H", _wrap_LoopyBeliefPropagation_H, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_BN", _wrap_LoopyBeliefPropagation_BN, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.UndefinedElement\n"
		"    If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_setEvidence", _wrap_LoopyBeliefPropagation_setEvidence, METH_VARARGS, NULL},
	 { "LoopyBeliefPropagation_updateEvidence", _wrap_LoopyBeliefPropagation_updateEvidence, METH_VARARGS, NULL},
	 { "LoopyBeliefPropagation_setTargets", _wrap_LoopyBeliefPropagation_setTargets, METH_VARARGS, NULL},
	 { "LoopyBeliefPropagation_hardEvidenceNodes", _wrap_LoopyBeliefPropagation_hardEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_softEvidenceNodes", _wrap_LoopyBeliefPropagation_softEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_targets", _wrap_LoopyBeliefPropagation_targets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_evidenceImpact", _wrap_LoopyBeliefPropagation_evidenceImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor 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 Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(targets|evs)\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_swigregister", LoopyBeliefPropagation_swigregister, METH_O, NULL},
	 { "LoopyBeliefPropagation_swiginit", LoopyBeliefPropagation_swiginit, METH_VARARGS, NULL},
	 { "new_ExactBNdistance", _wrap_new_ExactBNdistance, METH_VARARGS, NULL},
	 { "delete_ExactBNdistance", _wrap_delete_ExactBNdistance, METH_O, NULL},
	 { "ExactBNdistance_compute", _wrap_ExactBNdistance_compute, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Dict[str,float]\n"
		"	a dictionnary containing the different values after the computation.\n"
		"\n"
		""},
	 { "ExactBNdistance_swigregister", ExactBNdistance_swigregister, METH_O, NULL},
	 { "ExactBNdistance_swiginit", ExactBNdistance_swiginit, METH_VARARGS, NULL},
	 { "new_GibbsBNdistance", _wrap_new_GibbsBNdistance, METH_VARARGS, NULL},
	 { "delete_GibbsBNdistance", _wrap_delete_GibbsBNdistance, METH_O, NULL},
	 { "GibbsBNdistance_setBurnIn", _wrap_GibbsBNdistance_setBurnIn, METH_VARARGS, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	size of burn in on number of iteration\n"
		"\n"
		""},
	 { "GibbsBNdistance_compute", _wrap_GibbsBNdistance_compute, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Dict[str,float]\n"
		"	a dictionnary containing the different values after the computation.\n"
		"\n"
		""},
	 { "GibbsBNdistance_setVerbosity", _wrap_GibbsBNdistance_setVerbosity, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "GibbsBNdistance_setEpsilon", _wrap_GibbsBNdistance_setEpsilon, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : float\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "GibbsBNdistance_setMinEpsilonRate", _wrap_GibbsBNdistance_setMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "GibbsBNdistance_setMaxIter", _wrap_GibbsBNdistance_setMaxIter, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "GibbsBNdistance_setMaxTime", _wrap_GibbsBNdistance_setMaxTime, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : float\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "GibbsBNdistance_setPeriodSize", _wrap_GibbsBNdistance_setPeriodSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "GibbsBNdistance_verbosity", _wrap_GibbsBNdistance_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "GibbsBNdistance_epsilon", _wrap_GibbsBNdistance_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "GibbsBNdistance_minEpsilonRate", _wrap_GibbsBNdistance_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "GibbsBNdistance_maxIter", _wrap_GibbsBNdistance_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "GibbsBNdistance_maxTime", _wrap_GibbsBNdistance_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "GibbsBNdistance_periodSize", _wrap_GibbsBNdistance_periodSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "GibbsBNdistance_nbrIterations", _wrap_GibbsBNdistance_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "GibbsBNdistance_currentTime", _wrap_GibbsBNdistance_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	get the current running time in second (float)\n"
		"\n"
		""},
	 { "GibbsBNdistance_messageApproximationScheme", _wrap_GibbsBNdistance_messageApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "GibbsBNdistance_history", _wrap_GibbsBNdistance_history, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "GibbsBNdistance__asIApproximationSchemeConfiguration", _wrap_GibbsBNdistance__asIApproximationSchemeConfiguration, METH_O, NULL},
	 { "GibbsBNdistance_nbrDrawnVar", _wrap_GibbsBNdistance_nbrDrawnVar, METH_O, "\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"
		"\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"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variables are drawn at random\n"
		"\n"
		""},
	 { "GibbsBNdistance_setDrawnAtRandom", _wrap_GibbsBNdistance_setDrawnAtRandom, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"_atRandom : bool\n"
		"  indicates if variables should be drawn at random\n"
		"\n"
		""},
	 { "GibbsBNdistance_swigregister", GibbsBNdistance_swigregister, METH_O, NULL},
	 { "GibbsBNdistance_swiginit", GibbsBNdistance_swiginit, METH_VARARGS, NULL},
	 { "new_BNDatabaseGenerator", _wrap_new_BNDatabaseGenerator, METH_O, NULL},
	 { "delete_BNDatabaseGenerator", _wrap_delete_BNDatabaseGenerator, METH_O, NULL},
	 { "BNDatabaseGenerator_setDiscretizedLabelModeRandom", _wrap_BNDatabaseGenerator_setDiscretizedLabelModeRandom, METH_O, "\n"
		"\n"
		"Set the discretized label mode to RANDOM (default mode) : sampling a `pyagrum.discretizedVariable` will give a random value from the uniform distribution on that interval.\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> import pyagrum as gum\n"
		">>> bn=gum.fastBN('A->B{yes|maybe|no}<-C->D->E<-F[1,1.5,3,10.2]<-B')\n"
		">>> g=gum.BNDatabaseGenerator(bn)\n"
		">>> g.setRandomVarOrder()\n"
		">>> g.drawSamples(5,\n"
		"...               {'B':'yes','E':'1'})\n"
		"-122.98754206579288\n"
		">>> g.setDiscretizedLabelModeRandom() # By default\n"
		">>> g.to_pandas()\n"
		"     B         F  A  C  E  D\n"
		"0  yes  2.802302  0  0  1  0\n"
		"1  yes  1.761605  0  0  1  0\n"
		"2  yes  2.507535  0  0  1  1\n"
		"3  yes  2.815282  0  1  1  0\n"
		"4  yes  5.548571  1  0  1  1\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_setDiscretizedLabelModeMedian", _wrap_BNDatabaseGenerator_setDiscretizedLabelModeMedian, METH_O, "\n"
		"\n"
		"Set the discretized label mode to MEDIAN : sampling a `pyagrum.discretizedVariable` will give a deterministic value : the median of the uniform distribution on that interval.\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> import pyagrum as gum\n"
		">>> bn=gum.fastBN('A->B{yes|maybe|no}<-C->D->E<-F[1,1.5,3,10.2]<-B')\n"
		">>> g=gum.BNDatabaseGenerator(bn)\n"
		">>> g.setRandomVarOrder()\n"
		">>> g.drawSamples(5,\n"
		"...               {'B':'yes','E':'1'})\n"
		"-122.98754206579288\n"
		">>> g.setDiscretizedLabelModeMedian()\n"
		">>> g.to_pandas()\n"
		"     B         F  A  C  E  D\n"
		"0  yes  2.250000  0  0  1  0\n"
		"1  yes  2.250000  0  0  1  0\n"
		"2  yes  2.250000  0  0  1  1\n"
		"3  yes  2.250000  0  1  1  0\n"
		"4  yes  6.600000  1  0  1  1\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_setDiscretizedLabelModeInterval", _wrap_BNDatabaseGenerator_setDiscretizedLabelModeInterval, METH_O, "\n"
		"\n"
		"Set the discretized label mode to INTERVAL : sampling a `pyagrum.discretizedVariable` will give a deterministic value : the string representation of the interval.\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> import pyagrum as gum\n"
		">>> bn=gum.fastBN('A->B{yes|maybe|no}<-C->D->E<-F[1,1.5,3,10.2]<-B')\n"
		">>> g=gum.BNDatabaseGenerator(bn)\n"
		">>> g.setRandomVarOrder()\n"
		">>> g.drawSamples(5,\n"
		"...               {'B':'yes','E':'1'})\n"
		"-122.98754206579288\n"
		">>> g.setDiscretizedLabelModeInterval()\n"
		">>> g.to_pandas()\n"
		"     B         F  A  C  E  D\n"
		"0  yes   [1.5;3[  0  0  1  0\n"
		"1  yes   [1.5;3[  0  0  1  0\n"
		"2  yes   [1.5;3[  0  0  1  1\n"
		"3  yes   [1.5;3[  0  1  1  0\n"
		"4  yes  [3;10.2]  1  0  1  1\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_toCSV", _wrap_BNDatabaseGenerator_toCSV, METH_VARARGS, "\n"
		"\n"
		"generates csv representing the generated database.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"csvFilename: str\n"
		"  the name of the csv file\n"
		"useLabels: bool\n"
		"  whether label or id in the csv file (default true)\n"
		"append: bool\n"
		"  append in the file or rewrite the file (default false)\n"
		"csvSeparator: str\n"
		"  separator in the csv file (default ',')\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_samplesNbRows", _wrap_BNDatabaseGenerator_samplesNbRows, METH_O, "\n"
		"\n"
		"return the number of rows in the samples\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_samplesNbCols", _wrap_BNDatabaseGenerator_samplesNbCols, METH_O, "\n"
		"\n"
		"return the number of columns in the samples\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_samplesAt", _wrap_BNDatabaseGenerator_samplesAt, METH_VARARGS, "\n"
		"\n"
		"Get the value of the database in (row,col)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"row : int\n"
		"  the row\n"
		"col : int\n"
		"  the column (using the ordered list of variables)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the index of the modality of the variable in this position\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_samplesLabelAt", _wrap_BNDatabaseGenerator_samplesLabelAt, METH_VARARGS, "\n"
		"\n"
		"Get the label of the database in (row,col)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"row : int\n"
		"  the row\n"
		"col : int\n"
		"  the column (using the ordered list of variables)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"  the label of the modality of the variable in this position\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_setVarOrder", _wrap_BNDatabaseGenerator_setVarOrder, METH_VARARGS, "\n"
		"\n"
		"Set a specific order with a list of names\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"vars : List[str]\n"
		"  order specified by the list of variable names.\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_setVarOrderFromCSV", _wrap_BNDatabaseGenerator_setVarOrderFromCSV, METH_VARARGS, "\n"
		"\n"
		"Set the same order than in a csv file\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"filename:str\n"
		"  the name of the CSV file\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_setTopologicalVarOrder", _wrap_BNDatabaseGenerator_setTopologicalVarOrder, METH_O, "\n"
		"\n"
		"Select a topological order for the variables in the database.\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_setAntiTopologicalVarOrder", _wrap_BNDatabaseGenerator_setAntiTopologicalVarOrder, METH_O, "\n"
		"\n"
		"Select an anti-topological order for the variables in the database.\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_setRandomVarOrder", _wrap_BNDatabaseGenerator_setRandomVarOrder, METH_O, "\n"
		"\n"
		"Select an random order for the variables in the database.\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_varOrderNames", _wrap_BNDatabaseGenerator_varOrderNames, METH_O, "\n"
		"\n"
		"The actual order for the variable (as a tuple of NodeId)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tuple[str]\n"
		"  the tuple of names\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_log2likelihood", _wrap_BNDatabaseGenerator_log2likelihood, METH_O, "\n"
		"\n"
		"Get the  log2likelihood of the generated database\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"  if nothing has been sampled yet (using `gum.BNDatabaseGenerator.drawSamples()` for instance)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the log2likelihood\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_bn", _wrap_BNDatabaseGenerator_bn, METH_O, "\n"
		"\n"
		"Get the Bayesian network used to generate the samples\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BayesNet\n"
		"  The Bayesian network\n"
		"\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_varOrder", _wrap_BNDatabaseGenerator_varOrder, METH_O, "\n"
		"\n"
		"The actual order for the variable (as a tuple of NodeId)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tuple[int]\n"
		"  the tuple of NodeId\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_drawSamples", _wrap_BNDatabaseGenerator_drawSamples, METH_VARARGS, "\n"
		"\n"
		"Generate and stock a database generated by sampling the Bayesian network.\n"
		"\n"
		"If `evs` is specified, the samples are stored only if there are compatible with these observations.\n"
		"\n"
		"Returns the log2likelihood of this database.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nbSamples : int\n"
		"	the number of samples that will be generated\n"
		"evs : gum::Instantiation or Dict[int|str,int|str]\n"
		"  (optional) The evidence that will be observed by the resulting samples.\n"
		"timeout : int\n"
		"  (optional) The maximum time in seconds to generate the samples (default 600)\n"
		"\n"
		"Warning\n"
		"-------\n"
		"`nbSamples` is not the number of generated samples but the size of the database.It may happen that the evidence is very rare (or even impossible). In this case, the generation process may be *very* slow (it may even not stop). For this case a timeout is provided (default 600 seconds) and then the size of the database can be smaller than `nbSamples` (even equal to 0).\n"
		"\n"
		"Warning\n"
		"-------\n"
		"For discretized variable, aGrum/pyAgrum defines 3 behaviors when generating sample with labels :\n"
		"- RANDOM (default) : the value is chosen randomly in the interval\n"
		"- MEDIAN : the value is the median of the interval\n"
		"- INTERVAL : the value is the interval itself (for instance `« [0,1[ »`)\n"
		"\n"
		"The behavior can be set using `setDiscretizedLabelMode{Random|Median|Interval}`.\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> import pyagrum as gum\n"
		">>> bn=gum.fastBN('A->B{yes|maybe|no}<-C->D->E<-F[1,1.5,3,10.2]<-B')\n"
		">>> g=gum.BNDatabaseGenerator(bn)\n"
		">>> g.setRandomVarOrder()\n"
		">>> g.drawSamples(5,\n"
		"...               {'B':'yes','E':'1'})\n"
		"-122.98754206579288\n"
		">>> g.setDiscretizedLabelModeRandom() # By default\n"
		">>> g.to_pandas()\n"
		"     B         F  A  C  E  D\n"
		"0  yes  2.802302  0  0  1  0\n"
		"1  yes  1.761605  0  0  1  0\n"
		"2  yes  2.507535  0  0  1  1\n"
		"3  yes  2.815282  0  1  1  0\n"
		"4  yes  5.548571  1  0  1  1\n"
		">>> g.setDiscretizedLabelModeMedian()\n"
		">>> g.to_pandas()\n"
		"     B         F  A  C  E  D\n"
		"0  yes  2.250000  0  0  1  0\n"
		"1  yes  2.250000  0  0  1  0\n"
		"2  yes  2.250000  0  0  1  1\n"
		"3  yes  2.250000  0  1  1  0\n"
		"4  yes  6.600000  1  0  1  1\n"
		">>> g.setDiscretizedLabelModeInterval()\n"
		">>> g.to_pandas()\n"
		"     B         F  A  C  E  D\n"
		"0  yes   [1.5;3[  0  0  1  0\n"
		"1  yes   [1.5;3[  0  0  1  0\n"
		"2  yes   [1.5;3[  0  0  1  1\n"
		"3  yes   [1.5;3[  0  1  1  0\n"
		"4  yes  [3;10.2]  1  0  1  1\n"
		"\n"
		""},
	 { "BNDatabaseGenerator_swigregister", BNDatabaseGenerator_swigregister, METH_O, NULL},
	 { "BNDatabaseGenerator_swiginit", BNDatabaseGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_BNLearner", _wrap_new_BNLearner, METH_VARARGS, NULL},
	 { "delete_BNLearner", _wrap_delete_BNLearner, METH_O, NULL},
	 { "BNLearner_learnBN", _wrap_BNLearner_learnBN, METH_O, "\n"
		"\n"
		"Learns a BayesNet (both parameters and structure) from the BNLearner's database\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BayesNet\n"
		"	the learnt BayesNet\n"
		"\n"
		""},
	 { "BNLearner_learnParameters", _wrap_BNLearner_learnParameters, METH_VARARGS, "\n"
		"\n"
		"Creates a Bayes net whose structure corresponds to that passed in argument or to\n"
		"the last structure learnt by Method `learnDAG()`, and whose parameters are learnt\n"
		"from the BNLearner's database.\n"
		"\n"
		"usage:\n"
		"  1. `learnParameters(dag, take_into_account_score=True)`\n"
		"  2. `learnParameters(bn, take_into_account_score=True)`\n"
		"  3. `learnParameters(take_into_account_score=True)`\n"
		"\n"
		"When the first argument of Method `learnParameters()` is a DAG or a Bayes net\n"
		"(usages 1. and 2.), this one specifies the graphical structure of the returned\n"
		"Bayes net. Otherwise (usage 3.), Method `learnParameters()` is called implicitly\n"
		"with the last DAG learnt by the BNLearner.\n"
		"\n"
		"The difference between calling this method with a DAG (usages 1. and 3.) or a\n"
		"Bayes net (usage 2.) arises when the database contains missing values and EM is\n"
		"used to learn the parameters. EM needs to initialize the conditional probability\n"
		"distributions (CPT) before iterating the expectation/maximimzation steps. When a\n"
		"DAG is passed in argument, these initializations are performed using a specific\n"
		"estimator that does not take into account the missing values in the database. The\n"
		"resulting CPTs are then perturbed randomly (see the noise in method `useEM()`).\n"
		"When a Bayes net is passed in argument, its CPT for a node A can be either filled\n"
		"exclusively with zeroes or not. In the first case, the initialization is performed\n"
		"as described above. In the second case, the value of A's CPT is used as is, and\n"
		"a subsequent perturbation controlled by the noise level is applied.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dag : pyagrum.DAG\n"
		"	specifies the graphical structure of the returned Bayes net.\n"
		"bn : pyagrum.BayesNet\n"
		"	specifies the graphical structure of the returned Bayes net and, when\n"
		"	the database contains missing values and EM is used for learning, force\n"
		"	EM to initialize the CPTs of the resulting Bayes net to the values of\n"
		"	those passed in argument (when they are not fully filled with zeroes)\n"
		"	before iterating over the expectation/maximization steps.\n"
		"take_into_account_score : bool, default=True\n"
		"	The graphical structure passed in argument may have been learnt from a\n"
		"	structure learning. In this case, if the score used to learn the structure\n"
		"	has an implicit prior (like K2 which has a 1-smoothing prior), it is important\n"
		"	to also take into account this implicit prior for parameter learning. By\n"
		"	default (`take_into_account_score=True`), we will learn parameters by taking\n"
		"	into account the prior specified by methods usePriorXXX() + the implicit prior\n"
		"	of the score (if any). If `take_into_account_score=False`, we just take into\n"
		"	account the prior specified by `usePriorXXX()`.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BayesNet\n"
		"	the learnt BayesNet\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.MissingVariableInDatabase\n"
		"	If a variable of the Bayes net is not found in the database\n"
		"pyagrum.MissingValueInDatabase\n"
		"	If the database contains some missing values and EM is not used for the learning\n"
		"pyagrum.OperationNotAllowed\n"
		"	If EM is used but no stopping criterion has been selected\n"
		"pyagrum.UnknownLabelInDatabase\n"
		"	If a label is found in the database that do not correspond to the variable\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"When using a `pyagrum.DAG` as input parameter, the NodeIds in the dag and index of\n"
		"rows in the database must fit in order to coherently fix the structure of the BN.\n"
		"Generally, it is safer to use a `pyagrum.BayesNet` as input or even to use\n"
		"`pyagrum.BNLearner.fitParameters`.\n"
		"\n"
		""},
	 { "BNLearner_copyState", _wrap_BNLearner_copyState, METH_VARARGS, "\n"
		"\n"
		"Copy the state of the given pyagrum.BNLearner (as argument).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pyagrum.BNLearner\n"
		"    the learner whose state is copied.\n"
		"\n"
		""},
	 { "BNLearner_setInitialDAG", _wrap_BNLearner_setInitialDAG, METH_VARARGS, "\n"
		"\n"
		"Sets the initial structure (DAG) used by the structure learning algorithm.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dag : pyagrum.DAG\n"
		"	an initial pyagrum.DAG structure\n"
		"\n"
		""},
	 { "BNLearner_useEM", _wrap_BNLearner_useEM, METH_VARARGS, "\n"
		"\n"
		"Sets whether we use EM for parameter learning or not, depending on the value of epsilon.\n"
		"\n"
		"usage:\n"
		"  * `useEM(epsilon, noise=0.1)`\n"
		"\n"
		"When epsilon is equal to 0.0, EM is forbidden, else EM is used for parameter learning\n"
		"whenever the database contains missing values. In this case, its stopping criterion\n"
		"is a threshold on the log-likelihood evolution rate, i.e., if llc and llo refer to\n"
		"the log-likelihoods at the current and previous EM steps respectively, EM will stop\n"
		"when (llc - llo) / llc drops below epsilon. If you wish to be more specific on which\n"
		"stopping criterion to use, you may prefer exploiting methods `useEMWithRateCriterion()`\n"
		"or `useEMWithDiffCriterion()`.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"epsilon : float\n"
		"	if epsilon>0 then EM is used and stops whenever the relative difference between two\n"
		"	consecutive log-likelihoods (log-likelihood evolution rate) drops below epsilon.\n"
		"\n"
		"	if epsilon=0.0 then EM is not used. But if you wish to forbid the use of EM, prefer\n"
		"	executing Method `forbidEM()` rather than useEM(0.0) as it is more unequivocal.\n"
		"\n"
		"noise: float, default=0.1\n"
		"        During EM's initialization, the CPTs are randomly perturbed using the following formula:\n"
		"        new_CPT = (1-noise) * CPT + noise * random_CPT. Parameter noise must belong\n"
		"        to interval [0,1]. By default, noise is equal to 0.1.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"        if `epsilon` is strictly negative or if `noise` does not belong to interval [0,1].\n"
		"\n"
		""},
	 { "BNLearner_useEMWithRateCriterion", _wrap_BNLearner_useEMWithRateCriterion, METH_VARARGS, "\n"
		"\n"
		"Enforces that EM with the log-likelihood min evolution rate stopping criterion will be\n"
		"used for parameter learning when the dataset contains missing values.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"epsilon : float\n"
		"     epsilon sets the approximation stopping criterion: EM stops whenever the absolute\n"
		"     value of the relative difference between two consecutive log-likelihoods drops below\n"
		"     epsilon. Note that epsilon should be strictly positive.\n"
		"\n"
		"noise: float, default=0.1\n"
		"        During EM's initialization, the CPTs are randomly perturbed using the following formula:\n"
		"        new_CPT = (1-noise) * CPT + noise * random_CPT. Parameter noise must belong\n"
		"        to interval [0,1]. By default, noise is equal to 0.1.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"        if `epsilon` is not strictly positive or if `noise` does not belong to interval [0,1].\n"
		"\n"
		""},
	 { "BNLearner_useEMWithDiffCriterion", _wrap_BNLearner_useEMWithDiffCriterion, METH_VARARGS, "\n"
		"\n"
		"Enforces that EM with the log-likelihood min difference criterion will be used for\n"
		"parameter learning whenever the dataset contains missing values.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"epsilon : float\n"
		"     epsilon sets the approximation stopping criterion: EM stops whenever the\n"
		"     difference between two consecutive log-likelihoods drops below\n"
		"     epsilon. Note that epsilon should be strictly positive.\n"
		"\n"
		"noise: float (optional, default = 0.1)\n"
		"        During EM's initialization, the CPTs are randomly perturbed using the following formula:\n"
		"        new_CPT = (1-noise) * CPT + noise * random_CPT. Parameter noise must belong\n"
		"        to interval [0,1]. By default, noise is equal to 0.1.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"        if epsilon is not strictly positive or if noise does not belong to interval [0,1].\n"
		"\n"
		""},
	 { "BNLearner_forbidEM", _wrap_BNLearner_forbidEM, METH_O, "\n"
		"\n"
		"Forbids the use of EM for parameter learning.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		""},
	 { "BNLearner_EMsetEpsilon", _wrap_BNLearner_EMsetEpsilon, METH_VARARGS, "\n"
		"\n"
		"Enforces that the minimal difference between two consecutive log-likelihoods\n"
		"is chosen as a stopping criterion of the EM parameter learning algorithm and\n"
		"specifies the threshold on this criterion.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps: float\n"
		"        the log-likelihood difference below which EM stops its iterations\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"        If eps <= 0.\n"
		"\n"
		""},
	 { "BNLearner_EMdisableEpsilon", _wrap_BNLearner_EMdisableEpsilon, METH_O, "\n"
		"\n"
		"Disables the minimal difference between two consecutive log-likelihoods as a\n"
		"stopping criterion for the EM parameter learning algorithm.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		""},
	 { "BNLearner_EMenableEpsilon", _wrap_BNLearner_EMenableEpsilon, METH_O, "\n"
		"\n"
		"Enforces that the minimal difference between two consecutive log-likelihoods is\n"
		"a stopping criterion for the EM parameter learning algorithm.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		"Warnings:\n"
		"---------\n"
		"Setting the min difference between two consecutive log-likelihoods as a stopping\n"
		"criterion disables the min log-likelihood evolution rate as a stopping criterion.\n"
		"\n"
		""},
	 { "BNLearner_EMsetMinEpsilonRate", _wrap_BNLearner_EMsetMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Enforces that the minimal log-likelihood's evolution rate is considered by the EM\n"
		"parameter learning algorithm as a stopping criterion.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate: float\n"
		"	the log-likelihood evolution rate below which EM stops its iterations\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If rate <= 0.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Setting this stopping criterion disables the min log-likelihod difference criterion\n"
		"(if this one was enabled).\n"
		"\n"
		""},
	 { "BNLearner_EMdisableMinEpsilonRate", _wrap_BNLearner_EMdisableMinEpsilonRate, METH_O, "\n"
		"\n"
		"Disables the minimal log-likelihood's evolution rate as an EM parameter learning\n"
		"stopping criterion.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		""},
	 { "BNLearner_EMenableMinEpsilonRate", _wrap_BNLearner_EMenableMinEpsilonRate, METH_O, "\n"
		"\n"
		"Enables the minimal log-likelihood's evolution rate as an EM parameter learning\n"
		"stopping criterion.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Setting this stopping criterion disables the min log-likelihod difference criterion.\n"
		"\n"
		""},
	 { "BNLearner_EMsetMaxIter", _wrap_BNLearner_EMsetMaxIter, METH_VARARGS, "\n"
		"\n"
		"Enforces a limit on the number of expectation/maximization steps performed by EM.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximal number of iterations that EM is allowed to perform\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1.\n"
		"\n"
		""},
	 { "BNLearner_EMdisableMaxIter", _wrap_BNLearner_EMdisableMaxIter, METH_O, "\n"
		"\n"
		"Do not limit EM to perform a maximal number of iterations.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		""},
	 { "BNLearner_EMenableMaxIter", _wrap_BNLearner_EMenableMaxIter, METH_O, "\n"
		"\n"
		"Enables a limit on the number of iterations performed by EM. This number is\n"
		"equal to the last number specified with Method `EMsetMaxIter()`.\n"
		"See Method `EMMaxIter()` to get its current value.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		""},
	 { "BNLearner_EMsetMaxTime", _wrap_BNLearner_EMsetMaxTime, METH_VARARGS, "\n"
		"\n"
		"Adds a constraint on the time that EM is allowed to run for learning\n"
		"parameters.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"timeout : float\n"
		"	the timeout in milliseconds\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"        If timeout<=0.0\n"
		"\n"
		""},
	 { "BNLearner_EMdisableMaxTime", _wrap_BNLearner_EMdisableMaxTime, METH_O, "\n"
		"\n"
		"Allow EM to learn parameters for an infinite amount of time.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		""},
	 { "BNLearner_EMenableMaxTime", _wrap_BNLearner_EMenableMaxTime, METH_O, "\n"
		"\n"
		"Forbid EM to run more than a given amount of time.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		""},
	 { "BNLearner_EMsetPeriodSize", _wrap_BNLearner_EMsetPeriodSize, METH_VARARGS, NULL},
	 { "BNLearner_EMPeriodSize", _wrap_BNLearner_EMPeriodSize, METH_O, NULL},
	 { "BNLearner_EMsetVerbosity", _wrap_BNLearner_EMsetVerbosity, METH_VARARGS, "\n"
		"\n"
		"Sets or unsets the verbosity of the EM parameter learning algorithm.\n"
		"\n"
		"Verbosity is necessary for keeping track of the history of the learning.\n"
		"See Method `EMHistory()`.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"	sets EM's verbose mode if and only if v = True.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() methods.\n"
		"\n"
		""},
	 { "BNLearner_useScoreAIC", _wrap_BNLearner_useScoreAIC, METH_O, "\n"
		"\n"
		"Indicate that we wish to use an AIC score.\n"
		"\n"
		""},
	 { "BNLearner_useScoreBD", _wrap_BNLearner_useScoreBD, METH_O, "\n"
		"\n"
		"Indicate that we wish to use a BD score.\n"
		"\n"
		""},
	 { "BNLearner_useScoreBDeu", _wrap_BNLearner_useScoreBDeu, METH_O, "\n"
		"\n"
		"Indicate that we wish to use a BDeu score.\n"
		"\n"
		""},
	 { "BNLearner_useScoreBIC", _wrap_BNLearner_useScoreBIC, METH_O, "\n"
		"\n"
		"Indicate that we wish to use a BIC score.\n"
		"\n"
		""},
	 { "BNLearner_useScoreK2", _wrap_BNLearner_useScoreK2, METH_O, "\n"
		"\n"
		"Indicate that we wish to use a K2 score.\n"
		"\n"
		""},
	 { "BNLearner_useScoreLog2Likelihood", _wrap_BNLearner_useScoreLog2Likelihood, METH_O, "\n"
		"\n"
		"Indicate that we wish to use a Log2Likelihood score.\n"
		"\n"
		""},
	 { "BNLearner_useNoPrior", _wrap_BNLearner_useNoPrior, METH_O, "\n"
		"\n"
		"Use no prior.\n"
		"\n"
		""},
	 { "BNLearner_useBDeuPrior", _wrap_BNLearner_useBDeuPrior, METH_VARARGS, "\n"
		"\n"
		"The BDeu prior 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 : float\n"
		"	the prior weight\n"
		"\n"
		""},
	 { "BNLearner_useSmoothingPrior", _wrap_BNLearner_useSmoothingPrior, METH_VARARGS, "\n"
		"\n"
		"Use the prior smoothing.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"weight : float\n"
		"        pass in argument a weight if you wish to assign a weight to the smoothing, otherwise the current weight of the learner will be used.\n"
		"\n"
		""},
	 { "BNLearner_useDirichletPrior", _wrap_BNLearner_useDirichletPrior, METH_VARARGS, "\n"
		"\n"
		"Use the Dirichlet prior.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"source : str|pyagrum.BayesNet\n"
		"        the Dirichlet related source (filename of a database or a Bayesian network)\n"
		"weight : float (optional)\n"
		"        the weight of the prior (the 'size' of the corresponding 'virtual database')\n"
		"\n"
		""},
	 { "BNLearner_useGreedyHillClimbing", _wrap_BNLearner_useGreedyHillClimbing, METH_O, "\n"
		"\n"
		"Indicate that we wish to use a greedy hill climbing algorithm.\n"
		"\n"
		""},
	 { "BNLearner_useLocalSearchWithTabuList", _wrap_BNLearner_useLocalSearchWithTabuList, METH_VARARGS, "\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_useMIIC", _wrap_BNLearner_useMIIC, METH_O, "\n"
		"\n"
		"Indicate that we wish to use MIIC.\n"
		"\n"
		""},
	 { "BNLearner_useNMLCorrection", _wrap_BNLearner_useNMLCorrection, METH_O, "\n"
		"\n"
		"Indicate that we wish to use the NML correction for MIIC\n"
		"\n"
		""},
	 { "BNLearner_useMDLCorrection", _wrap_BNLearner_useMDLCorrection, METH_O, "\n"
		"\n"
		"Indicate that we wish to use the MDL correction for MIIC\n"
		"\n"
		""},
	 { "BNLearner_useNoCorrection", _wrap_BNLearner_useNoCorrection, METH_O, "\n"
		"\n"
		"Indicate that we wish to use the NoCorr correction for MIIC\n"
		"\n"
		""},
	 { "BNLearner_setMaxIndegree", _wrap_BNLearner_setMaxIndegree, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max_indegree : int\n"
		"	the limit number of parents\n"
		"\n"
		""},
	 { "BNLearner_addForbiddenArc", _wrap_BNLearner_addForbiddenArc, METH_VARARGS, "\n"
		"\n"
		"Forbid the arc passed in argument to be added during structure learning\n"
		"(methods `learnDAG()` or `learnBN()`).\n"
		"\n"
		"Usage:\n"
		"  1. addForbiddenArc(tail, head)\n"
		"  2. addForbiddenArc(arc)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arc : pyagrum.Arc\n"
		"	an arc\n"
		"head : int | str\n"
		"	a variable's id or name\n"
		"tail : int | str\n"
		"	a variable's id or name\n"
		"\n"
		""},
	 { "BNLearner_eraseForbiddenArc", _wrap_BNLearner_eraseForbiddenArc, METH_VARARGS, "\n"
		"\n"
		"Allow the arc to be added if necessary.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arc: pyagrum.Arc\n"
		"	an arc\n"
		"head : int | str\n"
		"	a variable's id or name\n"
		"tail : int | str\n"
		"	a variable's id or name\n"
		"\n"
		""},
	 { "BNLearner_addMandatoryArc", _wrap_BNLearner_addMandatoryArc, METH_VARARGS, "\n"
		"\n"
		"Allow an arc to be added if necessary during structure learning\n"
		"(methods `learnDAG()` or `learnBN()`).\n"
		"\n"
		"Usage:\n"
		"  1. addMandatoryArc(tail, head)\n"
		"  2. addMandatoryArc(arc)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arc : pyagrum.Arc\n"
		"	an arc\n"
		"head : int | str\n"
		"	a variable's id or name\n"
		"tail : int | str\n"
		"	a variable's id or name\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidDirectedCycle\n"
		"	If the added arc creates a directed cycle in the DAG\n"
		"\n"
		""},
	 { "BNLearner_eraseMandatoryArc", _wrap_BNLearner_eraseMandatoryArc, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arc: pyagrum.Arc\n"
		"	an arc\n"
		"head : int | str\n"
		"	a variable's id or name\n"
		"tail : int | str\n"
		"	a variable's id or name\n"
		"\n"
		""},
	 { "BNLearner_addPossibleEdge", _wrap_BNLearner_addPossibleEdge, METH_VARARGS, "\n"
		"\n"
		"assign a new possible edge\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"By default, all edge is possible. However, once at least one possible edge is defined,\n"
		"all other edges not declared possible are considered as impossible.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arc : pyagrum.Arc\n"
		"	an arc\n"
		"head : int | str\n"
		"	a variable's id or name\n"
		"tail : int | str\n"
		"	a variable's id or name\n"
		"\n"
		""},
	 { "BNLearner_erasePossibleEdge", _wrap_BNLearner_erasePossibleEdge, METH_VARARGS, "\n"
		"\n"
		"Allow the 2 arcs to be added if necessary.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arc : pyagrum.Arc\n"
		"	an arc\n"
		"head : int | str\n"
		"	a variable's id or name\n"
		"tail : int | str\n"
		"	a variable's id or name\n"
		"\n"
		""},
	 { "BNLearner_setPossibleSkeleton", _wrap_BNLearner_setPossibleSkeleton, METH_VARARGS, "\n"
		"\n"
		"Add a constraint by fixing the set of possible edges as a pyagrum.UndiGraph.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"g : pyagrum.UndiGraph\n"
		"	the fixed skeleton\n"
		"\n"
		""},
	 { "BNLearner_addNoParentNode", _wrap_BNLearner_addNoParentNode, METH_VARARGS, "\n"
		"\n"
		"Add the constraint that this node cannot have any parent.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node : int | str\n"
		"	a variable's id or name\n"
		"\n"
		""},
	 { "BNLearner_eraseNoParentNode", _wrap_BNLearner_eraseNoParentNode, METH_VARARGS, "\n"
		"\n"
		"Remove the constraint that this node cannot have any parent.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node : int | str\n"
		"	a variable's id or name\n"
		"\n"
		""},
	 { "BNLearner_addNoChildrenNode", _wrap_BNLearner_addNoChildrenNode, METH_VARARGS, "\n"
		"\n"
		"Add to structure learning algorithms the constraint that this node cannot have any children.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node : int | str\n"
		"	a variable's id or name\n"
		"\n"
		""},
	 { "BNLearner_eraseNoChildrenNode", _wrap_BNLearner_eraseNoChildrenNode, METH_VARARGS, "\n"
		"\n"
		"Remove in structure learning algorithms the constraint that this node cannot have any children.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node : int | str\n"
		"	a variable's id or name\n"
		"\n"
		""},
	 { "BNLearner_isConstraintBased", _wrap_BNLearner_isConstraintBased, METH_O, "\n"
		"\n"
		"Return wether the current learning method is constraint-based or not.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the current learning method is constraint-based.\n"
		"\n"
		""},
	 { "BNLearner_isScoreBased", _wrap_BNLearner_isScoreBased, METH_O, "\n"
		"\n"
		"Return wether the current learning method is score-based or not.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the current learning method is score-based.\n"
		"\n"
		""},
	 { "BNLearner___repr__", _wrap_BNLearner___repr__, METH_O, NULL},
	 { "BNLearner___str__", _wrap_BNLearner___str__, METH_O, NULL},
	 { "BNLearner_setVerbosity", _wrap_BNLearner_setVerbosity, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "BNLearner_setEpsilon", _wrap_BNLearner_setEpsilon, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : float\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "BNLearner_setMinEpsilonRate", _wrap_BNLearner_setMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "BNLearner_setMaxIter", _wrap_BNLearner_setMaxIter, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "BNLearner_setMaxTime", _wrap_BNLearner_setMaxTime, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : float\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "BNLearner_setPeriodSize", _wrap_BNLearner_setPeriodSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "BNLearner_verbosity", _wrap_BNLearner_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "BNLearner_epsilon", _wrap_BNLearner_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "BNLearner_minEpsilonRate", _wrap_BNLearner_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "BNLearner_maxIter", _wrap_BNLearner_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "BNLearner_maxTime", _wrap_BNLearner_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "BNLearner_periodSize", _wrap_BNLearner_periodSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "BNLearner_nbrIterations", _wrap_BNLearner_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "BNLearner_currentTime", _wrap_BNLearner_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	get the current running time in second (float)\n"
		"\n"
		""},
	 { "BNLearner_messageApproximationScheme", _wrap_BNLearner_messageApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "BNLearner_history", _wrap_BNLearner_history, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "BNLearner__asIApproximationSchemeConfiguration", _wrap_BNLearner__asIApproximationSchemeConfiguration, METH_O, NULL},
	 { "BNLearner_learnDAG", _wrap_BNLearner_learnDAG, METH_O, "\n"
		"\n"
		"learn a structure from a file\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DAG\n"
		"	the learned DAG\n"
		"\n"
		""},
	 { "BNLearner_learnPDAG", _wrap_BNLearner_learnPDAG, METH_O, "\n"
		"\n"
		"learn a partially directed acyclic graph (PDAG) from the BNLearner's database\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.PDAG\n"
		"	the learned PDAG\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"  The learning method must be constraint-based (MIIC, etc.) and not score-based\n"
		"  (K2, GreedyHillClimbing, etc.)\n"
		"\n"
		""},
	 { "BNLearner_names", _wrap_BNLearner_names, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tuple[str]\n"
		"        the names of the variables in the database\n"
		"\n"
		""},
	 { "BNLearner_idFromName", _wrap_BNLearner_idFromName, METH_VARARGS, "\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"
		"pyagrum.MissingVariableInDatabase\n"
		"	If a variable of the BN is not found in the database.\n"
		"\n"
		""},
	 { "BNLearner_nameFromId", _wrap_BNLearner_nameFromId, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id\n"
		"        a node id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"        the variable's name\n"
		"\n"
		""},
	 { "BNLearner_setDatabaseWeight", _wrap_BNLearner_setDatabaseWeight, METH_VARARGS, "\n"
		"\n"
		"Set the database weight which is given as an equivalent sample size.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"The same weight is assigned to all the rows of the learning database so that the sum of their\n"
		"weights is equal to the value of the parameter `weight`.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"weight : float\n"
		"        the database weight\n"
		"\n"
		""},
	 { "BNLearner_setRecordWeight", _wrap_BNLearner_setRecordWeight, METH_VARARGS, "\n"
		"\n"
		"Set the weight of the ith record\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : int\n"
		"  the position  of the record in the database\n"
		"weight : float\n"
		"  the weight assigned to this record\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"  if i is outside the set of indices of the records\n"
		"\n"
		""},
	 { "BNLearner_databaseWeight", _wrap_BNLearner_databaseWeight, METH_O, "\n"
		"\n"
		"Get the database weight which is given as an equivalent sample size.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  The weight of the database\n"
		"\n"
		""},
	 { "BNLearner_recordWeight", _wrap_BNLearner_recordWeight, METH_VARARGS, "\n"
		"\n"
		"Get the weight of the ith record\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : int\n"
		"  the position  of the record in the database\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"  if i is outside the set of indices of the records\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  The weight of the ith record of the database\n"
		"\n"
		""},
	 { "BNLearner_hasMissingValues", _wrap_BNLearner_hasMissingValues, METH_O, "\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"
		"\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"
		"float\n"
		"        the log-likelihood (base 2)\n"
		"\n"
		""},
	 { "BNLearner_score", _wrap_BNLearner_score, METH_VARARGS, "\n"
		"\n"
		"Returns the value of the score currently in use by the BNLearner of a variable given a set of other variables\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name1: str\n"
		"	the name of the variable at the LHS of the conditioning bar\n"
		"\n"
		"knowing : List[str]\n"
		"	the list of names of the conditioning variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the score\n"
		"\n"
		""},
	 { "BNLearner_mutualInformation", _wrap_BNLearner_mutualInformation, METH_VARARGS, "\n"
		"\n"
		"computes the (log2) mutual information between two columns, given a list of other columns.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"This function gives the 'raw' mutual information. If you want a version taking into account correction and prior, use\n"
		"gum.BNLearner.correctedMutualInformation\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 : List[str]\n"
		"        the list of names of conditioning columns\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the log2 mutual information\n"
		"\n"
		""},
	 { "BNLearner_correctedMutualInformation", _wrap_BNLearner_correctedMutualInformation, METH_VARARGS, "\n"
		"\n"
		"computes the mutual information between two columns, given a list of other columns (log2).\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"This function takes into account correction and prior. If you want the 'raw' mutual information, use\n"
		"gum.BNLearner.mutualInformation\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 : List[str]\n"
		"        the list of names of conditioning columns\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tuple[float,float]\n"
		"        the G2 statistic and the associated p-value as a Tuple\n"
		"\n"
		""},
	 { "BNLearner_rawPseudoCount", _wrap_BNLearner_rawPseudoCount, METH_VARARGS, "\n"
		"\n"
		"computes the pseudoCount (taking priors into account) of the list of variables as a list of floats.\n"
		"\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"vars: List[int|str]\n"
		"        the list of variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List[float]\n"
		"        the pseudo-count as a list of float\n"
		"\n"
		""},
	 { "BNLearner_nbRows", _wrap_BNLearner_nbRows, METH_O, "\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"
		"\n"
		"Return the number of columns in the database\n"
		"\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"        the number of columns in the database\n"
		"\n"
		""},
	 { "BNLearner_domainSize", _wrap_BNLearner_domainSize, METH_VARARGS, "\n"
		"\n"
		"Return the domain size of the variable with the given name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : str | int\n"
		"  the name of the id of the variable\n"
		"\n"
		""},
	 { "BNLearner_isUsingEM", _wrap_BNLearner_isUsingEM, METH_O, "\n"
		"\n"
		"returns a Boolean indicating whether EM is used for parameter learning when\n"
		"the database contains missing values.\n"
		"\n"
		""},
	 { "BNLearner_EMEpsilon", _wrap_BNLearner_EMEpsilon, METH_O, "\n"
		"\n"
		"Returns a float corresponding to the minimal difference between two consecutive\n"
		"log-likelihoods under which the EM parameter learning algorithm stops.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"       the minimal difference between two consecutive log-likelihoods under which EM stops.\n"
		"\n"
		""},
	 { "BNLearner_EMisEnabledEpsilon", _wrap_BNLearner_EMisEnabledEpsilon, METH_O, "\n"
		"\n"
		"Returns a Boolean indicating whether the minimal difference between two consecutive\n"
		"log-likelihoods is a stopping criterion for the EM parameter learning algorithm.\n"
		"\n"
		""},
	 { "BNLearner_EMMinEpsilonRate", _wrap_BNLearner_EMMinEpsilonRate, METH_O, "\n"
		"\n"
		"Returns a float corresponding to the minimal log-likelihood's evolution rate under\n"
		"which the EM parameter learning algorithm stops its iterations.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the limit under which EM stops its expectation/maximization iterations\n"
		"\n"
		""},
	 { "BNLearner_EMisEnabledMinEpsilonRate", _wrap_BNLearner_EMisEnabledMinEpsilonRate, METH_O, "\n"
		"\n"
		"Returns a Boolean indicating whether the minimal log-likelihood's evolution rate is\n"
		"considered as a stopping criterion by the EM parameter learning algorithm.\n"
		"\n"
		""},
	 { "BNLearner_EMMaxIter", _wrap_BNLearner_EMMaxIter, METH_O, "\n"
		"\n"
		"Returns an int containing the max number of iterations the EM parameter learning\n"
		"algorithm is allowed to perform when the max iterations stopping criterion is enabled.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the max number of expectation/maximization iterations EM is allowed to perform\n"
		"\n"
		""},
	 { "BNLearner_EMisEnabledMaxIter", _wrap_BNLearner_EMisEnabledMaxIter, METH_O, "\n"
		"\n"
		"Returns a Boolean indicating whether the max number of iterations is used\n"
		"by EM as a stopping criterion.\n"
		"\n"
		""},
	 { "BNLearner_EMMaxTime", _wrap_BNLearner_EMMaxTime, METH_O, "\n"
		"\n"
		"Returns a float indicating EM's time limit when the max time stopping\n"
		"criterion is used by the EM parameter learning algorithm.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"        the max time EM is allowed to execute its expectation/maximization iterations\n"
		"\n"
		""},
	 { "BNLearner_EMisEnabledMaxTime", _wrap_BNLearner_EMisEnabledMaxTime, METH_O, "\n"
		"\n"
		"Returns a Boolean indicating whether the max time criterion is used as\n"
		"an EM stopping criterion.\n"
		"\n"
		""},
	 { "BNLearner_EMVerbosity", _wrap_BNLearner_EMVerbosity, METH_O, "\n"
		"\n"
		"Returns a Boolean indicating whether the EM parameter learning algorithm\n"
		"is in a verbose mode.\n"
		"\n"
		"Note that EM verbosity is necessary for recording the history of the\n"
		"log-likelihoods computed at each expectation/maximization step.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"        indicates whether EM's verbose mode is active or not\n"
		"\n"
		""},
	 { "BNLearner_EMnbrIterations", _wrap_BNLearner_EMnbrIterations, METH_O, "\n"
		"\n"
		"Returns the number of iterations performed by the EM parameter learning algorithm.\n"
		"\n"
		""},
	 { "BNLearner_EMHistory", _wrap_BNLearner_EMHistory, METH_O, "\n"
		"\n"
		"Returns a list containing the log-likelihoods recorded after each\n"
		"expectation/maximization iteration of the EM parameter learning algorithm.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List[float]\n"
		"        A list of all the log-likelihoods recorded during EM's execution\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Recording log-likelihoods is enabled only when EM is executed in verbose\n"
		"mode. See method `EMsetVerbosity()`.\n"
		"\n"
		""},
	 { "BNLearner_EMStateApproximationScheme", _wrap_BNLearner_EMStateApproximationScheme, METH_O, NULL},
	 { "BNLearner_EMStateMessage", _wrap_BNLearner_EMStateMessage, METH_O, NULL},
	 { "BNLearner_setNumberOfThreads", _wrap_BNLearner_setNumberOfThreads, METH_VARARGS, "\n"
		"\n"
		"If the parameter n passed in argument is different from 0, the BNLearner will use n threads during learning, hence overriding pyAgrum default number of threads.\n"
		"If, on the contrary, n is equal to 0, the BNLearner will comply with pyAgrum default number of threads.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int\n"
		"	the number of threads to be used by the BNLearner\n"
		"\n"
		""},
	 { "BNLearner_getNumberOfThreads", _wrap_BNLearner_getNumberOfThreads, METH_O, "\n"
		"\n"
		"Return the number of threads used by the BNLearner during structure and parameter learning.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of threads used by the BNLearner during structure and parameter learning\n"
		"\n"
		""},
	 { "BNLearner_isGumNumberOfThreadsOverriden", _wrap_BNLearner_isGumNumberOfThreadsOverriden, METH_O, "\n"
		"\n"
		"Check if the number of threads use by the learner is the default one or not.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the number of threads used by the BNLearner has been set.\n"
		"\n"
		""},
	 { "BNLearner_chi2", _wrap_BNLearner_chi2, METH_VARARGS, "\n"
		"\n"
		"chi2 computes the chi2 statistic and p-value of two variables conditionally to a\n"
		"list of other variables.\n"
		"\n"
		"The variables correspond to columns in the database and are specified as the\n"
		"names of these columns in the database. The list of variables in the conditioning\n"
		"set can be empty. In this case, no need to specify it.\n"
		"\n"
		"Usage:\n"
		"  * `chi2(name1, name2, knowing=[])`\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name1: str\n"
		"        the name of a variable/column in the database\n"
		"\n"
		"name2 : str\n"
		"        the name/column of another variable\n"
		"\n"
		"knowing : List[str]\n"
		"        the list of the column names of the conditioning variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tuple[float,float]\n"
		"        the chi2 statistics and the associated p-value as a Tuple\n"
		"\n"
		""},
	 { "BNLearner_G2", _wrap_BNLearner_G2, METH_VARARGS, "\n"
		"\n"
		"G2 computes the G2 statistic and p-value of two variables conditionally to a\n"
		"list of other variables.\n"
		"\n"
		"The variables correspond to columns in the database and are specified as the\n"
		"names of these columns in the database. The list of variables in the conditioning\n"
		"set can be empty. In this case, no need to specify it.\n"
		"\n"
		"Usage:\n"
		"  * `G2(name1, name2, knowing=[])`\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name1: str\n"
		"        the name of a variable/column in the database\n"
		"\n"
		"name2 : str\n"
		"        the name/column of another variable\n"
		"\n"
		"knowing : List[str]\n"
		"        the list of the column names of the conditioning variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tuple[float,float]\n"
		"        the G2 statistics and the corresponding p-value as a Tuple\n"
		"\n"
		""},
	 { "BNLearner__EM_warning", _wrap_BNLearner__EM_warning, METH_O, NULL},
	 { "BNLearner_setSliceOrder", _wrap_BNLearner_setSliceOrder, METH_VARARGS, "\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_useK2", _wrap_BNLearner_useK2, METH_VARARGS, "\n"
		"\n"
		"Indicate to use the K2 algorithm (which needs a total ordering of the variables).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"order : list[int or str]\n"
		"      sequences of (ids or name)\n"
		"\n"
		""},
	 { "BNLearner_latentVariables", _wrap_BNLearner_latentVariables, METH_O, "\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"learner must be using MIIC algorithm\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of latent variables\n"
		"\n"
		""},
	 { "BNLearner_state", _wrap_BNLearner_state, METH_O, "\n"
		"\n"
		"Returns a dictionary containing the current state of the BNLearner.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Dict[str,Any]\n"
		"    a dictionary containing the current state of the BNLearner.\n"
		"\n"
		""},
	 { "BNLearner_setPossibleEdges", _wrap_BNLearner_setPossibleEdges, METH_VARARGS, "\n"
		"\n"
		"Adds a constraint to the structure learning algorithm by fixing the set of possible edges.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"edges : Set[Tuple[int]]\n"
		"	a set of edges as couples of nodeIds.\n"
		"\n"
		""},
	 { "BNLearner_swigregister", BNLearner_swigregister, METH_O, NULL},
	 { "BNLearner_swiginit", BNLearner_swiginit, METH_VARARGS, NULL},
	 { "new_CredalNet", _wrap_new_CredalNet, METH_VARARGS, NULL},
	 { "delete_CredalNet", _wrap_delete_CredalNet, METH_O, NULL},
	 { "CredalNet_addVariable", _wrap_CredalNet_addVariable, METH_VARARGS, "\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"
		"\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"
		"pyagrum.InvalidDirectedCircle\n"
		"	If any (directed) cycle is created by this arc\n"
		"pyagrum.InvalidNode\n"
		"	If head or tail does not belong to the graph nodes\n"
		"pyagrum.DuplicateElement\n"
		"	If one of the arc already exists\n"
		"\n"
		""},
	 { "CredalNet_setCPTs", _wrap_CredalNet_setCPTs, METH_VARARGS, "\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\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 : float\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\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_computeBinaryCPTMinMax", _wrap_CredalNet_computeBinaryCPTMinMax, METH_O, NULL},
	 { "CredalNet_src_bn", _wrap_CredalNet_src_bn, METH_O, "\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\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"
		"\n"
		"Returns\n"
		"-------\n"
		"float\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"
		"\n"
		"Returns\n"
		"-------\n"
		"float\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"
		"\n"
		"Returns\n"
		"-------\n"
		"float\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"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if this CredalNet is separately and interval specified, False otherwise.\n"
		"\n"
		""},
	 { "CredalNet_hasComputedBinaryCPTMinMax", _wrap_CredalNet_hasComputedBinaryCPTMinMax, METH_O, NULL},
	 { "CredalNet_get_binaryCPT_min", _wrap_CredalNet_get_binaryCPT_min, METH_O, "\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_binaryCPT_max", _wrap_CredalNet_get_binaryCPT_max, METH_O, "\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, NULL},
	 { "CredalNet___str__", _wrap_CredalNet___str__, METH_O, NULL},
	 { "CredalNet_swigregister", CredalNet_swigregister, METH_O, NULL},
	 { "CredalNet_swiginit", CredalNet_swiginit, METH_VARARGS, NULL},
	 { "new_CNMonteCarloSampling", _wrap_new_CNMonteCarloSampling, METH_O, NULL},
	 { "delete_CNMonteCarloSampling", _wrap_delete_CNMonteCarloSampling, METH_O, NULL},
	 { "CNMonteCarloSampling_makeInference", _wrap_CNMonteCarloSampling_makeInference, METH_O, "\n"
		"\n"
		"Starts the inference.\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_insertEvidenceFile", _wrap_CNMonteCarloSampling_insertEvidenceFile, METH_VARARGS, "\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"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_setEpsilon", _wrap_CNMonteCarloSampling_setEpsilon, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : float\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_setMinEpsilonRate", _wrap_CNMonteCarloSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_setMaxIter", _wrap_CNMonteCarloSampling_setMaxIter, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_setMaxTime", _wrap_CNMonteCarloSampling_setMaxTime, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : float\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_setPeriodSize", _wrap_CNMonteCarloSampling_setPeriodSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_verbosity", _wrap_CNMonteCarloSampling_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_epsilon", _wrap_CNMonteCarloSampling_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_minEpsilonRate", _wrap_CNMonteCarloSampling_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_maxIter", _wrap_CNMonteCarloSampling_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_maxTime", _wrap_CNMonteCarloSampling_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_periodSize", _wrap_CNMonteCarloSampling_periodSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_nbrIterations", _wrap_CNMonteCarloSampling_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_currentTime", _wrap_CNMonteCarloSampling_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	get the current running time in second (float)\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_messageApproximationScheme", _wrap_CNMonteCarloSampling_messageApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_history", _wrap_CNMonteCarloSampling_history, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "CNMonteCarloSampling__asIApproximationSchemeConfiguration", _wrap_CNMonteCarloSampling__asIApproximationSchemeConfiguration, METH_O, NULL},
	 { "CNMonteCarloSampling_setRepetitiveInd", _wrap_CNMonteCarloSampling_setRepetitiveInd, METH_VARARGS, "\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"
		"\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"
		"  pyagrum.IndexError\n"
		"	If the node does not belong to the Credal network\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_marginalMin", _wrap_CNMonteCarloSampling_marginalMin, METH_VARARGS, "\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"
		"  pyagrum.IndexError\n"
		"	If the node does not belong to the Credal network\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_insertModalsFile", _wrap_CNMonteCarloSampling_insertModalsFile, METH_VARARGS, "\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"
		"\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"
		"float\n"
		"    a constant reference to the variable upper expectation over all time steps.\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_dynamicExpMin", _wrap_CNMonteCarloSampling_dynamicExpMin, METH_VARARGS, "\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"
		"float\n"
		"    a constant reference to the variable lower expectation over all time steps.\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_eraseAllEvidence", _wrap_CNMonteCarloSampling_eraseAllEvidence, METH_O, "\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"
		""},
	 { "CNMonteCarloSampling_addEvidence", _wrap_CNMonteCarloSampling_addEvidence, METH_VARARGS, NULL},
	 { "CNMonteCarloSampling_CN", _wrap_CNMonteCarloSampling_CN, METH_O, NULL},
	 { "CNMonteCarloSampling_swigregister", CNMonteCarloSampling_swigregister, METH_O, NULL},
	 { "CNMonteCarloSampling_swiginit", CNMonteCarloSampling_swiginit, METH_VARARGS, NULL},
	 { "CNLoopyPropagation_makeInference", _wrap_CNLoopyPropagation_makeInference, METH_O, "\n"
		"\n"
		"Starts the inference.\n"
		"\n"
		""},
	 { "CNLoopyPropagation_inferenceType", _wrap_CNLoopyPropagation_inferenceType, METH_VARARGS, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the inference type\n"
		"\n"
		""},
	 { "CNLoopyPropagation_saveInference", _wrap_CNLoopyPropagation_saveInference, METH_VARARGS, "\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, NULL},
	 { "delete_CNLoopyPropagation", _wrap_delete_CNLoopyPropagation, METH_O, NULL},
	 { "CNLoopyPropagation_insertEvidenceFile", _wrap_CNLoopyPropagation_insertEvidenceFile, METH_VARARGS, "\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"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "CNLoopyPropagation_setEpsilon", _wrap_CNLoopyPropagation_setEpsilon, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : float\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "CNLoopyPropagation_setMinEpsilonRate", _wrap_CNLoopyPropagation_setMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "CNLoopyPropagation_setMaxIter", _wrap_CNLoopyPropagation_setMaxIter, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "CNLoopyPropagation_setMaxTime", _wrap_CNLoopyPropagation_setMaxTime, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : float\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "CNLoopyPropagation_setPeriodSize", _wrap_CNLoopyPropagation_setPeriodSize, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "CNLoopyPropagation_verbosity", _wrap_CNLoopyPropagation_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "CNLoopyPropagation_epsilon", _wrap_CNLoopyPropagation_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "CNLoopyPropagation_minEpsilonRate", _wrap_CNLoopyPropagation_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "CNLoopyPropagation_maxIter", _wrap_CNLoopyPropagation_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "CNLoopyPropagation_maxTime", _wrap_CNLoopyPropagation_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "CNLoopyPropagation_periodSize", _wrap_CNLoopyPropagation_periodSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"	If p<1\n"
		"\n"
		""},
	 { "CNLoopyPropagation_nbrIterations", _wrap_CNLoopyPropagation_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "CNLoopyPropagation_currentTime", _wrap_CNLoopyPropagation_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	get the current running time in second (float)\n"
		"\n"
		""},
	 { "CNLoopyPropagation_messageApproximationScheme", _wrap_CNLoopyPropagation_messageApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "CNLoopyPropagation_history", _wrap_CNLoopyPropagation_history, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "CNLoopyPropagation__asIApproximationSchemeConfiguration", _wrap_CNLoopyPropagation__asIApproximationSchemeConfiguration, METH_O, NULL},
	 { "CNLoopyPropagation_setRepetitiveInd", _wrap_CNLoopyPropagation_setRepetitiveInd, METH_VARARGS, "\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"
		"\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"
		"  pyagrum.IndexError\n"
		"	If the node does not belong to the Credal network\n"
		"\n"
		""},
	 { "CNLoopyPropagation_marginalMin", _wrap_CNLoopyPropagation_marginalMin, METH_VARARGS, "\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"
		"  pyagrum.IndexError\n"
		"	If the node does not belong to the Credal network\n"
		"\n"
		""},
	 { "CNLoopyPropagation_insertModalsFile", _wrap_CNLoopyPropagation_insertModalsFile, METH_VARARGS, "\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"
		"\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"
		"float\n"
		"    a constant reference to the variable upper expectation over all time steps.\n"
		"\n"
		""},
	 { "CNLoopyPropagation_dynamicExpMin", _wrap_CNLoopyPropagation_dynamicExpMin, METH_VARARGS, "\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"
		"float\n"
		"    a constant reference to the variable lower expectation over all time steps.\n"
		"\n"
		""},
	 { "CNLoopyPropagation_eraseAllEvidence", _wrap_CNLoopyPropagation_eraseAllEvidence, METH_O, "\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_addEvidence", _wrap_CNLoopyPropagation_addEvidence, METH_VARARGS, NULL},
	 { "CNLoopyPropagation_CN", _wrap_CNLoopyPropagation_CN, METH_O, NULL},
	 { "CNLoopyPropagation_swigregister", CNLoopyPropagation_swigregister, METH_O, NULL},
	 { "CNLoopyPropagation_swiginit", CNLoopyPropagation_swiginit, METH_VARARGS, NULL},
	 { "IDGenerator_generate", _wrap_IDGenerator_generate, METH_VARARGS, "\n"
		"\n"
		"Generate a new influence diagram given the parameters.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nbrNodes : int\n"
		"	the number of node\n"
		"arcDensity : float\n"
		"	the density of arc (1 for a complete graph)\n"
		"chanceNodeDensity : float\n"
		"	the density of chance node\n"
		"utilityNodeDensity : float\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"
		"\n"
		"IDGenerator is used to easily generate influence diagrams.\n"
		"\n"
		"IDGenerator() -> IDGenerator\n"
		"    default constructor\n"
		"\n"
		""},
	 { "delete_IDGenerator", _wrap_delete_IDGenerator, METH_O, NULL},
	 { "IDGenerator_swigregister", IDGenerator_swigregister, METH_O, NULL},
	 { "IDGenerator_swiginit", IDGenerator_swiginit, METH_VARARGS, NULL},
	 { "InfluenceDiagram_fastPrototype", _wrap_InfluenceDiagram_fastPrototype, METH_VARARGS, "\n"
		"\n"
		"Create an Influence Diagram with a dot-like syntax which specifies:\n"
		"    - the structure 'a->b<-c;b->d;c<-e;'.\n"
		"    - a prefix for the type of node (chance/decision/utiliy nodes):\n"
		"\n"
		"      - `a` : a chance node named 'a' (by default)\n"
		"      - `$a` : a utility node named 'a'\n"
		"      - `*a` : a decision node named 'a'\n"
		"\n"
		"    - the type of the variables with different syntax as postfix:\n"
		"\n"
		"      - by default, a variable is a pyagrum.RangeVariable using the default domain size (second argument)\n"
		"      - with `'a[10]'`, the variable is a pyagrum.RangeVariable using 10 as domain size (from 0 to 9)\n"
		"      - with `'a[3,7]'`, the variable is a pyagrum.RangeVariable using a domainSize from 3 to 7\n"
		"      - with `'a[1,3.14,5,6.2]'`, the variable is a pyagrum.DiscretizedVariable using the given ticks (at least 3 values)\n"
		"      - with `'a{top|middle|bottom}'`, the variable is a pyagrum.LabelizedVariable using the given labels.\n"
		"      - with 'a{-1|5|0|3}', the variable is a pyagrum.IntegerVariable using the sorted given values.\n"
		"      - with 'a{-0.5|5.01|0|3.1415}', the variable is a pyagrum.NumericalDiscreteVariable using the sorted given values.\n"
		"\n"
		"Note\n"
		"----\n"
		"  - If the dot-like string contains such a specification more than once for a variable, the first specification will be used.\n"
		"  - the tensors (probabilities, utilities) are randomly generated.\n"
		"  - see also pyagrum.fastID.\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> import pyagrum as gum\n"
		">>> bn=pyagrum.fastID('A->B[1,3]<-*C{yes|No}->$D<-E[1,2.5,3.9]',6)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dotlike : str\n"
		"        the string containing the specification\n"
		"domainSize :int or str\n"
		"        the default domain size or the default domain for variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.InfluenceDiagram\n"
		"        the resulting Influence Diagram\n"
		"\n"
		""},
	 { "delete_InfluenceDiagram", _wrap_delete_InfluenceDiagram, METH_O, NULL},
	 { "new_InfluenceDiagram", _wrap_new_InfluenceDiagram, METH_VARARGS, NULL},
	 { "InfluenceDiagram___eq__", _wrap_InfluenceDiagram___eq__, METH_VARARGS, NULL},
	 { "InfluenceDiagram___ne__", _wrap_InfluenceDiagram___ne__, METH_VARARGS, NULL},
	 { "InfluenceDiagram_toDot", _wrap_InfluenceDiagram_toDot, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format\n"
		"\n"
		""},
	 { "InfluenceDiagram_clear", _wrap_InfluenceDiagram_clear, METH_O, NULL},
	 { "InfluenceDiagram_cpt", _wrap_InfluenceDiagram_cpt, METH_VARARGS, "\n"
		"\n"
		"Returns the CPT of a variable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"	The variable's CPT.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"	If no variable's id matches varId.\n"
		"\n"
		""},
	 { "InfluenceDiagram_utility", _wrap_InfluenceDiagram_utility, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"	the utility table of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.IndexError\n"
		"	If the InfluenceDiagram does not contain the variable\n"
		"\n"
		""},
	 { "InfluenceDiagram_isUtilityNode", _wrap_InfluenceDiagram_isUtilityNode, METH_VARARGS, "\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"
		"\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"
		"\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"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of utility nodes\n"
		"\n"
		""},
	 { "InfluenceDiagram_chanceNodeSize", _wrap_InfluenceDiagram_chanceNodeSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of chance nodes.\n"
		"\n"
		""},
	 { "InfluenceDiagram_decisionNodeSize", _wrap_InfluenceDiagram_decisionNodeSize, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of decision nodes\n"
		"\n"
		""},
	 { "InfluenceDiagram_variable", _wrap_InfluenceDiagram_variable, METH_VARARGS, "\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"
		"pyagrum.NotFound\n"
		"	If no variable's id matches the parameter\n"
		"\n"
		""},
	 { "InfluenceDiagram_nodeId", _wrap_InfluenceDiagram_nodeId, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"	If the InfluenceDiagram does not contain the variable\n"
		"\n"
		""},
	 { "InfluenceDiagram_idFromName", _wrap_InfluenceDiagram_idFromName, METH_VARARGS, "\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"
		"pyagrum.NotFound\n"
		"	If no such name exists in the graph.\n"
		"\n"
		""},
	 { "InfluenceDiagram_variableFromName", _wrap_InfluenceDiagram_variableFromName, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	a variable's name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiscreteVariable\n"
		"	the variable\n"
		"\n"
		"Notes\n"
		"-----\n"
		"  A convenient shortcut for `g.variableFromName(name)` is `g[name]`.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.IndexError\n"
		"	If the InfluenceDiagram does not contain the variable\n"
		"\n"
		""},
	 { "InfluenceDiagram_add", _wrap_InfluenceDiagram_add, METH_VARARGS, "\n"
		"\n"
		"Add a 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 that will be a chance node.\n"
		"descr: str\n"
		"  the descr of the variable following :ref:`fast syntax<Quick specification of (randomly parameterized) graphical models>` extended for :func:`pyagrum.fastID`.\n"
		"nbr_mod_or_id : int\n"
		"	if the first argument is `variable`, this set an optional fixed id for the node. If the first argument is `descr`, this gives the default number of modalities\n"
		"	for the variable. Note that if a utility node is described in `descr`, this value is overriden by 1.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the id of the added variable.\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.DuplicateElement\n"
		"	  If already used id or name.\n"
		"\n"
		""},
	 { "InfluenceDiagram_addChanceNode", _wrap_InfluenceDiagram_addChanceNode, METH_VARARGS, "\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"
		"pyagrum.DuplicateElement\n"
		"	If id(<>0) is already used\n"
		"\n"
		""},
	 { "InfluenceDiagram_addUtilityNode", _wrap_InfluenceDiagram_addUtilityNode, METH_VARARGS, "\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"
		"pyagrum.InvalidArgument\n"
		"	If variable has more than one label\n"
		"pyagrum.DuplicateElement\n"
		"	If id(<>0) is already used\n"
		"\n"
		""},
	 { "InfluenceDiagram_addDecisionNode", _wrap_InfluenceDiagram_addDecisionNode, METH_VARARGS, "\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"
		"pyagrum.DuplicateElement\n"
		"	If id(<>0) is already used\n"
		"\n"
		""},
	 { "InfluenceDiagram_erase", _wrap_InfluenceDiagram_erase, METH_VARARGS, "\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 :  Union[int,str,pyagrum.DiscreteVariable]\n"
		"	a variable's id (int) or name or th reference on the variable to remove.\n"
		"\n"
		""},
	 { "InfluenceDiagram_changeVariableName", _wrap_InfluenceDiagram_changeVariableName, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"new_name : str\n"
		"	the name of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.DuplicateLabel\n"
		"	If this name already exists\n"
		"pyagrum.NotFound\n"
		"	If no nodes matches id.\n"
		"\n"
		""},
	 { "InfluenceDiagram_addArc", _wrap_InfluenceDiagram_addArc, METH_VARARGS, "\n"
		"\n"
		"Add an arc in the ID, and update diagram's tensor nodes cpt if necessary.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tail : Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"head : Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.InvalidEdge\n"
		"	If arc.tail and/or arc.head are not in the ID.\n"
		"  pyagrum.InvalidEdge\n"
		"	If tail is a utility node\n"
		"\n"
		""},
	 { "InfluenceDiagram_eraseArc", _wrap_InfluenceDiagram_eraseArc, METH_VARARGS, "\n"
		"\n"
		"Removes an arc in the ID, and update diagram's tensor 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 whn calling eraseArc(arc)\n"
		"tail : Union[int,str]\n"
		"	a variable's id (int) or name when calling eraseArc(tail,head)\n"
		"head : Union[int,str]\n"
		"	a variable's id (int) or name when calling eraseArc(tail,head)\n"
		"\n"
		""},
	 { "InfluenceDiagram_decisionOrderExists", _wrap_InfluenceDiagram_decisionOrderExists, METH_O, "\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"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DAG\n"
		"	the temporal Graph.\n"
		"\n"
		""},
	 { "InfluenceDiagram_decisionOrder", _wrap_InfluenceDiagram_decisionOrder, METH_O, NULL},
	 { "InfluenceDiagram_existsPathBetween", _wrap_InfluenceDiagram_existsPathBetween, METH_VARARGS, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	true if a path exists between two nodes.\n"
		"\n"
		""},
	 { "InfluenceDiagram_beginTopologyTransformation", _wrap_InfluenceDiagram_beginTopologyTransformation, METH_O, NULL},
	 { "InfluenceDiagram_endTopologyTransformation", _wrap_InfluenceDiagram_endTopologyTransformation, METH_O, NULL},
	 { "InfluenceDiagram_names", _wrap_InfluenceDiagram_names, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List[str]\n"
		"	The names of the InfluenceDiagram variables\n"
		"\n"
		""},
	 { "InfluenceDiagram_nodes", _wrap_InfluenceDiagram_nodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of ids\n"
		"\n"
		""},
	 { "InfluenceDiagram_arcs", _wrap_InfluenceDiagram_arcs, METH_O, "\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"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of the parents ids.\n"
		"\n"
		""},
	 { "InfluenceDiagram_children", _wrap_InfluenceDiagram_children, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"	the set of all the children\n"
		"\n"
		""},
	 { "InfluenceDiagram_family", _wrap_InfluenceDiagram_family, METH_VARARGS, "\n"
		"\n"
		"give the set of parents of a node and the node\n"
		"\n"
		"Parameters\n"
		"---------\n"
		"norid : str|int\n"
		"  the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of nodeId of the family of the node `norid`\n"
		"\n"
		""},
	 { "InfluenceDiagram_descendants", _wrap_InfluenceDiagram_descendants, METH_VARARGS, "\n"
		"\n"
		"give the set of nodeid of descendants of a node\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"norid : str|int\n"
		"  the name or the id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of ids of the descendants of node `norid`.\n"
		"\n"
		""},
	 { "InfluenceDiagram_ancestors", _wrap_InfluenceDiagram_ancestors, METH_VARARGS, "\n"
		"\n"
		"give the set of nodeid of ancestors of a node\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"norid : str|int\n"
		"  the name or the id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[int]\n"
		"  the set of ids of the ancestors of node `norid`.\n"
		"\n"
		""},
	 { "InfluenceDiagram_moralizedAncestralGraph", _wrap_InfluenceDiagram_moralizedAncestralGraph, METH_VARARGS, "\n"
		"\n"
		"build a UndiGraph by moralizing the Ancestral Graph of a list of nodes\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nodes : str|int|List[str|int]\n"
		"  the list of of nodeIds or names\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"  gum.UndiGraph only knows NodeId. Hence the moralized ancestral graph does not include the names of the variables.graph\n"
		"\n"
		"Returns\n"
		"-------\n"
		"gum.UndiGraph\n"
		"  the moralized ancestral graph of the nodes\n"
		"\n"
		""},
	 { "InfluenceDiagram_loadBIFXML", _wrap_InfluenceDiagram_loadBIFXML, METH_VARARGS, "\n"
		"\n"
		"Load a BIFXML file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the name's file\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.IOError\n"
		"	If file not found\n"
		"pyagrum.FatalError\n"
		"	If file is not valid\n"
		"\n"
		""},
	 { "InfluenceDiagram_saveBIFXML", _wrap_InfluenceDiagram_saveBIFXML, METH_VARARGS, "\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, NULL},
	 { "InfluenceDiagram___str__", _wrap_InfluenceDiagram___str__, METH_O, NULL},
	 { "InfluenceDiagram_swigregister", InfluenceDiagram_swigregister, METH_O, NULL},
	 { "InfluenceDiagram_swiginit", InfluenceDiagram_swiginit, METH_VARARGS, NULL},
	 { "new_ShaferShenoyLIMIDInference", _wrap_new_ShaferShenoyLIMIDInference, METH_O, NULL},
	 { "delete_ShaferShenoyLIMIDInference", _wrap_delete_ShaferShenoyLIMIDInference, METH_O, NULL},
	 { "ShaferShenoyLIMIDInference_junctionTree", _wrap_ShaferShenoyLIMIDInference_junctionTree, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CliqueGraph\n"
		"  the current junction tree\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_clear", _wrap_ShaferShenoyLIMIDInference_clear, METH_O, NULL},
	 { "ShaferShenoyLIMIDInference_addNoForgettingAssumption", _wrap_ShaferShenoyLIMIDInference_addNoForgettingAssumption, METH_VARARGS, NULL},
	 { "ShaferShenoyLIMIDInference_hasNoForgettingAssumption", _wrap_ShaferShenoyLIMIDInference_hasNoForgettingAssumption, METH_O, NULL},
	 { "ShaferShenoyLIMIDInference_reducedGraph", _wrap_ShaferShenoyLIMIDInference_reducedGraph, METH_O, "\n"
		"\n"
		"Returns the DAG build to solve the influence diagram.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DAG\n"
		"  a copy of the reduced graph\n"
		"\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_reversePartialOrder", _wrap_ShaferShenoyLIMIDInference_reversePartialOrder, METH_O, NULL},
	 { "ShaferShenoyLIMIDInference_reducedLIMID", _wrap_ShaferShenoyLIMIDInference_reducedLIMID, METH_O, "\n"
		"\n"
		"Returns the (reduced) LIMID build to solve the influence diagram.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.InfluenceDiagram\n"
		"  a copy of the reduced influence Diagram (LIMID)\n"
		"\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_isSolvable", _wrap_ShaferShenoyLIMIDInference_isSolvable, METH_O, "\n"
		"\n"
		"check wether the influence diagram is solvable or not\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if the influence diagram is solvable\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_optimalDecision", _wrap_ShaferShenoyLIMIDInference_optimalDecision, METH_VARARGS, "\n"
		"\n"
		"Returns best choice for decision variable given in parameter ( based upon MEU criteria )\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"decisionId : int,str\n"
		"	the id or name of the decision variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"  pyagrum.OperationNotAllowed\n"
		"	If no inference have yet been made\n"
		"pyagrum.InvalidNode\n"
		"	If node given in parmaeter is not a decision node\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_posteriorUtility", _wrap_ShaferShenoyLIMIDInference_posteriorUtility, METH_VARARGS, "\n"
		"\n"
		"Returns the posterior utiliyt of a utility node (after optimisation) depending on decision nodes, if any.\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.Tensor\n"
		"  a const ref to the posterior utility of the utility node\n"
		"\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_makeInference", _wrap_ShaferShenoyLIMIDInference_makeInference, METH_O, "\n"
		"\n"
		"Perform the heavy computations needed to compute the optimal decisions.\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_posterior", _wrap_ShaferShenoyLIMIDInference_posterior, METH_VARARGS, "\n"
		"\n"
		"Returns the posterior of a chance or a decision node (after optimisation).\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.Tensor\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_addEvidence", _wrap_ShaferShenoyLIMIDInference_addEvidence, METH_VARARGS, "\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"
		"  pyagrum.InvalidArgument\n"
		"    If the node already has an evidence\n"
		"  pyagrum.InvalidArgument\n"
		"    If val is not a value for the node\n"
		"  pyagrum.InvalidArgument\n"
		"    If the size of vals is different from the domain side of the node\n"
		"  pyagrum.FatalError\n"
		"    If vals is a vector of 0s\n"
		"  pyagrum.UndefinedElement\n"
		"    If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_chgEvidence", _wrap_ShaferShenoyLIMIDInference_chgEvidence, METH_VARARGS, "\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 : int|str\n"
		"  a node value or the label of the node value\n"
		"vals : List[float]\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"pyagrum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"pyagrum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"pyagrum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"pyagrum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_hasEvidence", _wrap_ShaferShenoyLIMIDInference_hasEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_eraseAllEvidence", _wrap_ShaferShenoyLIMIDInference_eraseAllEvidence, METH_O, "\n"
		"\n"
		"Remove all evidence.\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_eraseEvidence", _wrap_ShaferShenoyLIMIDInference_eraseEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_hasHardEvidence", _wrap_ShaferShenoyLIMIDInference_hasHardEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_hasSoftEvidence", _wrap_ShaferShenoyLIMIDInference_hasSoftEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_nbrEvidence", _wrap_ShaferShenoyLIMIDInference_nbrEvidence, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_nbrHardEvidence", _wrap_ShaferShenoyLIMIDInference_nbrHardEvidence, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of hard evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_nbrSoftEvidence", _wrap_ShaferShenoyLIMIDInference_nbrSoftEvidence, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of soft evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_influenceDiagram", _wrap_ShaferShenoyLIMIDInference_influenceDiagram, METH_O, "\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"
		""},
	 { "ShaferShenoyLIMIDInference_setEvidence", _wrap_ShaferShenoyLIMIDInference_setEvidence, METH_VARARGS, NULL},
	 { "ShaferShenoyLIMIDInference_updateEvidence", _wrap_ShaferShenoyLIMIDInference_updateEvidence, METH_VARARGS, NULL},
	 { "ShaferShenoyLIMIDInference_hardEvidenceNodes", _wrap_ShaferShenoyLIMIDInference_hardEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_softEvidenceNodes", _wrap_ShaferShenoyLIMIDInference_softEvidenceNodes, METH_O, NULL},
	 { "ShaferShenoyLIMIDInference_MEU", _wrap_ShaferShenoyLIMIDInference_MEU, METH_VARARGS, "\n"
		"\n"
		"Returns maximum expected utility obtained from inference.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"	If no inference have yet been made\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_meanVar", _wrap_ShaferShenoyLIMIDInference_meanVar, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict[str, float]\n"
		"  a dictionary with the mean and variance of the node (after the inference)\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_swigregister", ShaferShenoyLIMIDInference_swigregister, METH_O, NULL},
	 { "ShaferShenoyLIMIDInference_swiginit", ShaferShenoyLIMIDInference_swiginit, METH_VARARGS, NULL},
	 { "delete_IMarkovRandomField", _wrap_delete_IMarkovRandomField, METH_O, NULL},
	 { "IMarkovRandomField_smallestFactorFromNode", _wrap_IMarkovRandomField_smallestFactorFromNode, METH_VARARGS, NULL},
	 { "IMarkovRandomField_factors", _wrap_IMarkovRandomField_factors, METH_O, NULL},
	 { "IMarkovRandomField_variableNodeMap", _wrap_IMarkovRandomField_variableNodeMap, METH_O, NULL},
	 { "IMarkovRandomField_variable", _wrap_IMarkovRandomField_variable, METH_VARARGS, NULL},
	 { "IMarkovRandomField_nodeId", _wrap_IMarkovRandomField_nodeId, METH_VARARGS, NULL},
	 { "IMarkovRandomField_idFromName", _wrap_IMarkovRandomField_idFromName, METH_VARARGS, NULL},
	 { "IMarkovRandomField_variableFromName", _wrap_IMarkovRandomField_variableFromName, METH_VARARGS, NULL},
	 { "IMarkovRandomField___eq__", _wrap_IMarkovRandomField___eq__, METH_VARARGS, NULL},
	 { "IMarkovRandomField___ne__", _wrap_IMarkovRandomField___ne__, METH_VARARGS, NULL},
	 { "IMarkovRandomField_dim", _wrap_IMarkovRandomField_dim, METH_O, NULL},
	 { "IMarkovRandomField_maxVarDomainSize", _wrap_IMarkovRandomField_maxVarDomainSize, METH_O, NULL},
	 { "IMarkovRandomField_minParam", _wrap_IMarkovRandomField_minParam, METH_O, NULL},
	 { "IMarkovRandomField_maxParam", _wrap_IMarkovRandomField_maxParam, METH_O, NULL},
	 { "IMarkovRandomField_minNonZeroParam", _wrap_IMarkovRandomField_minNonZeroParam, METH_O, NULL},
	 { "IMarkovRandomField_maxNonOneParam", _wrap_IMarkovRandomField_maxNonOneParam, METH_O, NULL},
	 { "IMarkovRandomField_toDot", _wrap_IMarkovRandomField_toDot, METH_O, NULL},
	 { "IMarkovRandomField_toDotAsFactorGraph", _wrap_IMarkovRandomField_toDotAsFactorGraph, METH_O, NULL},
	 { "IMarkovRandomField_names", _wrap_IMarkovRandomField_names, METH_O, "\n"
		"\n"
		"Set of names of variables in the model\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[str]\n"
		"	The names of the graph variables\n"
		"\n"
		""},
	 { "IMarkovRandomField_nodes", _wrap_IMarkovRandomField_nodes, METH_O, NULL},
	 { "IMarkovRandomField_neighbours", _wrap_IMarkovRandomField_neighbours, METH_VARARGS, NULL},
	 { "IMarkovRandomField_edges", _wrap_IMarkovRandomField_edges, METH_O, NULL},
	 { "IMarkovRandomField_minimalCondSet", _wrap_IMarkovRandomField_minimalCondSet, METH_VARARGS, NULL},
	 { "IMarkovRandomField_factor", _wrap_IMarkovRandomField_factor, METH_VARARGS, NULL},
	 { "IMarkovRandomField_isIndependent", _wrap_IMarkovRandomField_isIndependent, METH_VARARGS, "\n"
		"\n"
		"check if nodes X and nodes Y are independent given nodes Z\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"\n"
		"Raises\n"
		"------\n"
		"InvalidArgument\n"
		"  if X and Y share variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if X and Y are independent given Z in the model\n"
		"\n"
		""},
	 { "IMarkovRandomField___repr__", _wrap_IMarkovRandomField___repr__, METH_O, NULL},
	 { "IMarkovRandomField___str__", _wrap_IMarkovRandomField___str__, METH_O, NULL},
	 { "IMarkovRandomField_swigregister", IMarkovRandomField_swigregister, METH_O, NULL},
	 { "MarkovRandomField_fastPrototype", _wrap_MarkovRandomField_fastPrototype, METH_VARARGS, "\n"
		"\n"
		"Create a Markov random field with a modified dot-like syntax which specifies:\n"
		"    - the structure ``a-b-c;b-d-e;``. The substring ``a-b-c`` indicates a factor with the scope (a,b,c).\n"
		"    - the type of the variables with different syntax (cf documentation).\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> import pyagrum as gum\n"
		">>> bn=pyagrum.MarkovRandomField.fastPrototype('A--B[1,3]-C{yes|No}--D[2,4]--E[1,2.5,3.9]',6)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dotlike : str\n"
		"        the string containing the specification\n"
		"domainSize : int or str\n"
		"        the default domain size or the default domain for variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.MarkovRandomField\n"
		"        the resulting Markov random field\n"
		"\n"
		""},
	 { "MarkovRandomField_fromBN", _wrap_MarkovRandomField_fromBN, METH_O, NULL},
	 { "delete_MarkovRandomField", _wrap_delete_MarkovRandomField, METH_O, NULL},
	 { "new_MarkovRandomField", _wrap_new_MarkovRandomField, METH_VARARGS, NULL},
	 { "MarkovRandomField_smallestFactorFromNode", _wrap_MarkovRandomField_smallestFactorFromNode, METH_VARARGS, NULL},
	 { "MarkovRandomField_factors", _wrap_MarkovRandomField_factors, METH_O, NULL},
	 { "MarkovRandomField_variableNodeMap", _wrap_MarkovRandomField_variableNodeMap, METH_O, NULL},
	 { "MarkovRandomField_add", _wrap_MarkovRandomField_add, METH_VARARGS, "\n"
		"\n"
		"Add a variable to the pyagrum.MarkovRandomField.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyagrum.DiscreteVariable\n"
		"	the variable added\n"
		"name : str\n"
		"	the variable name\n"
		"nbrmod : int\n"
		"	the number of modalities for the new variable\n"
		"id : int\n"
		"	the variable forced id in the pyagrum.MarkovRandomField\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the new node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.DuplicateLabel\n"
		"    If variable.name() is already used in this pyagrum.MarkovRandomField.\n"
		"pyagrum.OperationNotAllowed\n"
		"    If nbrmod is less than 2\n"
		"pyagrum.DuplicateElement\n"
		"    If id is already used.\n"
		"\n"
		""},
	 { "MarkovRandomField_clear", _wrap_MarkovRandomField_clear, METH_O, "\n"
		"\n"
		"Clear the whole MarkovRandomField\n"
		"\n"
		""},
	 { "MarkovRandomField_erase", _wrap_MarkovRandomField_erase, METH_VARARGS, "\n"
		"\n"
		"Remove a variable from the gum::MarkovRandomField.\n"
		"\n"
		"Removes the corresponding variable from the gum::MarkovRandomField and from all of it's children gum::Tensor.\n"
		"\n"
		"If no variable matches the given id, then nothing is done.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var :Union[int,str,pyagrum.DiscreteVariable]\n"
		"	a variable's id (int) or name of variable or a reference of this variable to remove.\n"
		"\n"
		""},
	 { "MarkovRandomField_variable", _wrap_MarkovRandomField_variable, METH_VARARGS, NULL},
	 { "MarkovRandomField_changeVariableName", _wrap_MarkovRandomField_changeVariableName, METH_VARARGS, "\n"
		"\n"
		"Changes a variable's name in the gum::MarkovRandomField.\n"
		"\n"
		"This will change the gum::DiscreteVariable names in the gum::MarkovRandomField.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"car :Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"new_name : str\n"
		"	the new name of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.DuplicateLabel\n"
		"    If new_name is already used in this MarkovRandomField.\n"
		"pyagrum.NotFound\n"
		"    If no variable matches id.\n"
		"\n"
		""},
	 { "MarkovRandomField_changeVariableLabel", _wrap_MarkovRandomField_changeVariableLabel, METH_VARARGS, "\n"
		"\n"
		"change the label of the variable associated to nodeId to the new value.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var :Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"old_label : str\n"
		"	the old label\n"
		"new_label : str\n"
		"	the new label\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if id/name is not a variable or if old_label does not exist.\n"
		"\n"
		""},
	 { "MarkovRandomField_nodeId", _wrap_MarkovRandomField_nodeId, METH_VARARGS, NULL},
	 { "MarkovRandomField_idFromName", _wrap_MarkovRandomField_idFromName, METH_VARARGS, NULL},
	 { "MarkovRandomField_variableFromName", _wrap_MarkovRandomField_variableFromName, METH_VARARGS, NULL},
	 { "MarkovRandomField_generateFactors", _wrap_MarkovRandomField_generateFactors, METH_O, "\n"
		"\n"
		"Randomly generates factors parameters for a given structure.\n"
		"\n"
		""},
	 { "MarkovRandomField_generateFactor", _wrap_MarkovRandomField_generateFactor, METH_VARARGS, "\n"
		"\n"
		"Randomly generate factor parameters for a given factor in a given structure.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node : Union[int,str]\n"
		"	a variable's id (int) or name\n"
		"\n"
		""},
	 { "MarkovRandomField_beginTopologyTransformation", _wrap_MarkovRandomField_beginTopologyTransformation, METH_O, NULL},
	 { "MarkovRandomField_endTopologyTransformation", _wrap_MarkovRandomField_endTopologyTransformation, METH_O, "\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.MarkovRandomField\n"
		"\n"
		""},
	 { "MarkovRandomField_graph", _wrap_MarkovRandomField_graph, METH_O, NULL},
	 { "MarkovRandomField_size", _wrap_MarkovRandomField_size, METH_O, NULL},
	 { "MarkovRandomField_log10DomainSize", _wrap_MarkovRandomField_log10DomainSize, METH_O, "\n"
		"\n"
		"returns the log10 of the domain size of the model defined as the product of the domain sizes of the variables in the model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the log10 domain size.\n"
		"\n"
		""},
	 { "MarkovRandomField_names", _wrap_MarkovRandomField_names, METH_O, "\n"
		"\n"
		"Set of names of variables in the model\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set[str]\n"
		"	The names of the graph variables\n"
		"\n"
		""},
	 { "MarkovRandomField_nodes", _wrap_MarkovRandomField_nodes, METH_O, NULL},
	 { "MarkovRandomField_neighbours", _wrap_MarkovRandomField_neighbours, METH_VARARGS, NULL},
	 { "MarkovRandomField_edges", _wrap_MarkovRandomField_edges, METH_O, NULL},
	 { "MarkovRandomField_minimalCondSet", _wrap_MarkovRandomField_minimalCondSet, METH_VARARGS, NULL},
	 { "MarkovRandomField_factor", _wrap_MarkovRandomField_factor, METH_VARARGS, "\n"
		"\n"
		"Returns the factor of a set of variables (if existing).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"vars : Union[Set[int],Set[str]]\n"
		"	A set of ids or names of variable the pyagrum.MarkovRandomField.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"	The factor of the set of nodes.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    If no variable's id matches varId.\n"
		"\n"
		""},
	 { "MarkovRandomField_isIndependent", _wrap_MarkovRandomField_isIndependent, METH_VARARGS, "\n"
		"\n"
		"check if nodes X and nodes Y are independent given nodes Z\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|List[str|int]\n"
		"      a list of of nodeIds or names\n"
		"\n"
		"Raises\n"
		"------\n"
		"InvalidArgument\n"
		"  if X and Y share variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if X and Y are independent given Z in the model\n"
		"\n"
		""},
	 { "MarkovRandomField_loadUAI", _wrap_MarkovRandomField_loadUAI, METH_VARARGS, "\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"
		"pyagrum.IOError\n"
		"    If file not found\n"
		"pyagrum.FatalError\n"
		"    If file is not valid\n"
		"\n"
		""},
	 { "MarkovRandomField_saveUAI", _wrap_MarkovRandomField_saveUAI, METH_VARARGS, "\n"
		"\n"
		"Save the MarkovRandomField in an UAI file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"\n"
		""},
	 { "MarkovRandomField___repr__", _wrap_MarkovRandomField___repr__, METH_O, NULL},
	 { "MarkovRandomField___str__", _wrap_MarkovRandomField___str__, METH_O, NULL},
	 { "MarkovRandomField_addFactor", _wrap_MarkovRandomField_addFactor, METH_VARARGS, "\n"
		"\n"
		"Add a factor from a list or a set of id or str. If the argument is a set, the order is the order of the IDs of the variables\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"seq : sequence (list or set) of int or string\n"
		"	The sequence (ordered or not) of node id or names\n"
		"\n"
		""},
	 { "MarkovRandomField_eraseFactor", _wrap_MarkovRandomField_eraseFactor, METH_VARARGS, NULL},
	 { "MarkovRandomField_swigregister", MarkovRandomField_swigregister, METH_O, NULL},
	 { "MarkovRandomField_swiginit", MarkovRandomField_swiginit, METH_VARARGS, NULL},
	 { "new_ShaferShenoyMRFInference", _wrap_new_ShaferShenoyMRFInference, METH_VARARGS, NULL},
	 { "delete_ShaferShenoyMRFInference", _wrap_delete_ShaferShenoyMRFInference, METH_O, NULL},
	 { "ShaferShenoyMRFInference_setTriangulation", _wrap_ShaferShenoyMRFInference_setTriangulation, METH_VARARGS, NULL},
	 { "ShaferShenoyMRFInference_joinTree", _wrap_ShaferShenoyMRFInference_joinTree, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CliqueGraph\n"
		"  the current join tree used\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_junctionTree", _wrap_ShaferShenoyMRFInference_junctionTree, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CliqueGraph\n"
		"  the current junction tree\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_evidenceProbability", _wrap_ShaferShenoyMRFInference_evidenceProbability, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the probability of evidence\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_setNumberOfThreads", _wrap_ShaferShenoyMRFInference_setNumberOfThreads, METH_VARARGS, "\n"
		"\n"
		"If the argument nb is different from 0, this number of threads will be used during inferences, hence overriding aGrUM's default number of threads.\n"
		"If, on the contrary, nb is equal to 0, the parallelized inference engine will comply with aGrUM's default number of threads.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nb : int\n"
		"	the number of threads to be used by ShaferShenoyMRFInference\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_getNumberOfThreads", _wrap_ShaferShenoyMRFInference_getNumberOfThreads, METH_O, "\n"
		"\n"
		"returns the number of threads used by LazyPropagation during inferences.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of threads used by LazyPropagation during inferences\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_isGumNumberOfThreadsOverriden", _wrap_ShaferShenoyMRFInference_isGumNumberOfThreadsOverriden, METH_O, "\n"
		"\n"
		"Indicates whether LazyPropagation currently overrides aGrUM's default number of threads (see method setNumberOfThreads).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	A Boolean indicating whether LazyPropagation currently overrides aGrUM's default number of threads\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_setMaxMemory", _wrap_ShaferShenoyMRFInference_setMaxMemory, METH_VARARGS, "\n"
		"\n"
		"sets an upper bound on the memory consumption admissible\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"gigabytes: float\n"
		"  this upper bound in gigabytes.\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_makeInference", _wrap_ShaferShenoyMRFInference_makeInference, METH_O, "\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"
		""},
	 { "ShaferShenoyMRFInference_addEvidence", _wrap_ShaferShenoyMRFInference_addEvidence, METH_VARARGS, "\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"
		"  pyagrum.InvalidArgument\n"
		"    If the node already has an evidence\n"
		"  pyagrum.InvalidArgument\n"
		"    If val is not a value for the node\n"
		"  pyagrum.InvalidArgument\n"
		"    If the size of vals is different from the domain side of the node\n"
		"  pyagrum.FatalError\n"
		"    If vals is a vector of 0s\n"
		"  pyagrum.UndefinedElement\n"
		"    If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_chgEvidence", _wrap_ShaferShenoyMRFInference_chgEvidence, METH_VARARGS, "\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 : int|str\n"
		"  a node value or the label of the node value\n"
		"vals : List[float]\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"pyagrum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"pyagrum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"pyagrum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"pyagrum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_hasEvidence", _wrap_ShaferShenoyMRFInference_hasEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_eraseAllEvidence", _wrap_ShaferShenoyMRFInference_eraseAllEvidence, METH_O, "\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_eraseEvidence", _wrap_ShaferShenoyMRFInference_eraseEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_hasHardEvidence", _wrap_ShaferShenoyMRFInference_hasHardEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_hasSoftEvidence", _wrap_ShaferShenoyMRFInference_hasSoftEvidence, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_nbrEvidence", _wrap_ShaferShenoyMRFInference_nbrEvidence, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_nbrHardEvidence", _wrap_ShaferShenoyMRFInference_nbrHardEvidence, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of hard evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_nbrSoftEvidence", _wrap_ShaferShenoyMRFInference_nbrSoftEvidence, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of soft evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_eraseAllTargets", _wrap_ShaferShenoyMRFInference_eraseAllTargets, METH_O, "\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"
		""},
	 { "ShaferShenoyMRFInference_addAllTargets", _wrap_ShaferShenoyMRFInference_addAllTargets, METH_O, "\n"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_addTarget", _wrap_ShaferShenoyMRFInference_addTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_eraseTarget", _wrap_ShaferShenoyMRFInference_eraseTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_isTarget", _wrap_ShaferShenoyMRFInference_isTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_nbrTargets", _wrap_ShaferShenoyMRFInference_nbrTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_H", _wrap_ShaferShenoyMRFInference_H, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_MRF", _wrap_ShaferShenoyMRFInference_MRF, METH_O, NULL},
	 { "ShaferShenoyMRFInference_posterior", _wrap_ShaferShenoyMRFInference_posterior, METH_VARARGS, "\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.Tensor\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_eraseAllJointTargets", _wrap_ShaferShenoyMRFInference_eraseAllJointTargets, METH_O, "\n"
		"\n"
		"Clear all previously defined joint targets.\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_eraseAllMarginalTargets", _wrap_ShaferShenoyMRFInference_eraseAllMarginalTargets, METH_O, "\n"
		"\n"
		"Clear all the previously defined marginal targets.\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_nbrJointTargets", _wrap_ShaferShenoyMRFInference_nbrJointTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of joint targets\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_setEvidence", _wrap_ShaferShenoyMRFInference_setEvidence, METH_VARARGS, NULL},
	 { "ShaferShenoyMRFInference_updateEvidence", _wrap_ShaferShenoyMRFInference_updateEvidence, METH_VARARGS, NULL},
	 { "ShaferShenoyMRFInference_setTargets", _wrap_ShaferShenoyMRFInference_setTargets, METH_VARARGS, NULL},
	 { "ShaferShenoyMRFInference_hardEvidenceNodes", _wrap_ShaferShenoyMRFInference_hardEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_softEvidenceNodes", _wrap_ShaferShenoyMRFInference_softEvidenceNodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_targets", _wrap_ShaferShenoyMRFInference_targets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_evidenceImpact", _wrap_ShaferShenoyMRFInference_evidenceImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor 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 Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(targets|evs)\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_jointMutualInformation", _wrap_ShaferShenoyMRFInference_jointMutualInformation, METH_VARARGS, NULL},
	 { "ShaferShenoyMRFInference_evidenceJointImpact", _wrap_ShaferShenoyMRFInference_evidenceJointImpact, METH_VARARGS, "\n"
		"\n"
		"Create a pyagrum.Tensor for P(joint targets|evs) (for all instanciation of targets and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"targets : List[int|str]\n"
		"  a list of node Ids or node names\n"
		"evs : Set[int|str]\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a Tensor for P(target|evs)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.Exception\n"
		"  If some evidene entered into the Bayes net are incompatible (their joint proba = 0)\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_jointPosterior", _wrap_ShaferShenoyMRFInference_jointPosterior, METH_VARARGS, "\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 by the Tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"  a const ref to the posterior joint probability of the set of nodes.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_addJointTarget", _wrap_ShaferShenoyMRFInference_addJointTarget, METH_VARARGS, "\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"
		"pyagrum.UndefinedElement\n"
		"  If some node(s) do not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_eraseJointTarget", _wrap_ShaferShenoyMRFInference_eraseJointTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_isJointTarget", _wrap_ShaferShenoyMRFInference_isJointTarget, METH_VARARGS, "\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"
		"pyagrum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"pyagrum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_jointTargets", _wrap_ShaferShenoyMRFInference_jointTargets, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of target sets\n"
		"\n"
		""},
	 { "ShaferShenoyMRFInference_swigregister", ShaferShenoyMRFInference_swigregister, METH_O, NULL},
	 { "ShaferShenoyMRFInference_swiginit", ShaferShenoyMRFInference_swiginit, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

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__DAGTo_p_gum__ArcGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ArcGraphPart *) (gum::DiGraph *) ((gum::DAG *) 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__PDAGTo_p_gum__ArcGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ArcGraphPart *) (gum::DiGraph *)(gum::MixedGraph *) ((gum::PDAG *) x));
}
static void *_p_gum__DuplicateElementTo_p_gum__ArgumentError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ArgumentError *)  ((gum::DuplicateElement *) x));
}
static void *_p_gum__DuplicateLabelTo_p_gum__ArgumentError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ArgumentError *)  ((gum::DuplicateLabel *) x));
}
static void *_p_gum__InvalidArgumentTo_p_gum__ArgumentError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ArgumentError *)  ((gum::InvalidArgument *) x));
}
static void *_p_gum__InvalidArgumentsNumberTo_p_gum__ArgumentError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ArgumentError *)  ((gum::InvalidArgumentsNumber *) x));
}
static void *_p_gum__OutOfBoundsTo_p_gum__ArgumentError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ArgumentError *)  ((gum::OutOfBounds *) 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__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__BayesNetFragmentT_double_tTo_p_gum__DAGmodel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DAGmodel *) (gum::IBayesNet< double > *) ((gum::BayesNetFragment< double > *) 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__InfluenceDiagramT_double_tTo_p_gum__DAGmodel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DAGmodel *)  ((gum::InfluenceDiagram< double > *) 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__MixedGraphTo_p_gum__DiGraph(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiGraph *)  ((gum::MixedGraph *) x));
}
static void *_p_gum__PDAGTo_p_gum__DiGraph(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiGraph *) (gum::MixedGraph *) ((gum::PDAG *) x));
}
static void *_p_PythonBNListenerTo_p_gum__DiGraphListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiGraphListener *)  ((PythonBNListener *) x));
}
static void *_p_gum__BayesNetFragmentT_double_tTo_p_gum__DiGraphListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiGraphListener *)  ((gum::BayesNetFragment< double > *) 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__IDiscretizedVariableTo_p_gum__DiscreteVariable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteVariable *)  ((gum::IDiscretizedVariable *) x));
}
static void *_p_gum__IntegerVariableTo_p_gum__DiscreteVariable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteVariable *)  ((gum::IntegerVariable *) 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__NumericalDiscreteVariableTo_p_gum__DiscreteVariable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteVariable *)  ((gum::NumericalDiscreteVariable *) 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__CliqueGraphTo_p_gum__EdgeGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::EdgeGraphPart *) (gum::UndiGraph *) ((gum::CliqueGraph *) 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__PDAGTo_p_gum__EdgeGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::EdgeGraphPart *) (gum::UndiGraph *)(gum::MixedGraph *) ((gum::PDAG *) 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__AbstractScheduleMultiDimTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ScheduleMultiDimError *) ((gum::AbstractScheduleMultiDim *) x));
}
static void *_p_gum__ArgumentErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::ArgumentError *) 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__DatabaseErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::LearningError *) ((gum::DatabaseError *) 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__DuplicateElementTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ArgumentError *) ((gum::DuplicateElement *) x));
}
static void *_p_gum__DuplicateLabelTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ArgumentError *) ((gum::DuplicateLabel *) x));
}
static void *_p_gum__DuplicateScheduleMultiDimTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ScheduleMultiDimError *) ((gum::DuplicateScheduleMultiDim *) 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__FactoryInvalidStateTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::FactoryError *) ((gum::FactoryInvalidState *) 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__FormatNotFoundTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::IOError *) ((gum::FormatNotFound *) 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__IOErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::IOError *) 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__IncompatibleScorePriorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::LearningError *) ((gum::IncompatibleScorePrior *) 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__InvalidArgumentTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ArgumentError *) ((gum::InvalidArgument *) x));
}
static void *_p_gum__InvalidArgumentsNumberTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ArgumentError *) ((gum::InvalidArgumentsNumber *) 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__InvalidEdgeTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::GraphError *) ((gum::InvalidEdge *) 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__InvalidPartiallyDirectedCycleTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::GraphError *) ((gum::InvalidPartiallyDirectedCycle *) x));
}
static void *_p_gum__IteratorErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::IteratorError *) 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__MissingValueInDatabaseTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::LearningError *) ((gum::MissingValueInDatabase *) 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__NoChildTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::GraphError *) ((gum::NoChild *) 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__NoParentTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::GraphError *) ((gum::NoParent *) 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__NotImplementedYetTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::NotImplementedYet *) 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__OperationNotAllowedTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::OperationNotAllowed *) x));
}
static void *_p_gum__OutOfBoundsTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ArgumentError *) ((gum::OutOfBounds *) x));
}
static void *_p_gum__PRMTypeErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::FactoryError *) ((gum::PRMTypeError *) x));
}
static void *_p_gum__PossiblyIncompatibleScorePriorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::LearningError *) ((gum::PossiblyIncompatibleScorePrior *) x));
}
static void *_p_gum__ScheduleMultiDimErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::ScheduleMultiDimError *) x));
}
static void *_p_gum__ScheduleOperationErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::ScheduleOperationError *) 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__SyntaxErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::IOError *) ((gum::SyntaxError *) 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__UnavailableScheduleOperationTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ScheduleOperationError *) ((gum::UnavailableScheduleOperation *) 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__UndefinedIteratorKeyTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::IteratorError *) ((gum::UndefinedIteratorKey *) x));
}
static void *_p_gum__UndefinedIteratorValueTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::IteratorError *) ((gum::UndefinedIteratorValue *) x));
}
static void *_p_gum__UnexecutedScheduleOperationTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ScheduleOperationError *) ((gum::UnexecutedScheduleOperation *) 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__UnknownScheduleMultiDimTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ScheduleMultiDimError *) ((gum::UnknownScheduleMultiDim *) x));
}
static void *_p_gum__UnknownScheduleOperationTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ScheduleOperationError *) ((gum::UnknownScheduleOperation *) 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__FactoryInvalidStateTo_p_gum__FactoryError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::FactoryError *)  ((gum::FactoryInvalidState *) x));
}
static void *_p_gum__PRMTypeErrorTo_p_gum__FactoryError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::FactoryError *)  ((gum::PRMTypeError *) 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__WrongClassElementTo_p_gum__FactoryError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::FactoryError *)  ((gum::WrongClassElement *) x));
}
static void *_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_tTo_p_gum__GibbsSamplingT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GibbsSampling< double > *)  ((gum::LoopySamplingInference< double,gum::GibbsSampling > *) 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__InvalidArcTo_p_gum__GraphError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphError *)  ((gum::InvalidArc *) 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__InvalidEdgeTo_p_gum__GraphError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphError *)  ((gum::InvalidEdge *) 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__InvalidPartiallyDirectedCycleTo_p_gum__GraphError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphError *)  ((gum::InvalidPartiallyDirectedCycle *) 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__NoNeighbourTo_p_gum__GraphError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphError *)  ((gum::NoNeighbour *) 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__BayesNetT_double_tTo_p_gum__GraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphicalModel *) (gum::DAGmodel *)(gum::IBayesNet< double > *) ((gum::BayesNet< double > *) x));
}
static void *_p_gum__BayesNetFragmentT_double_tTo_p_gum__GraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphicalModel *) (gum::DAGmodel *)(gum::IBayesNet< double > *) ((gum::BayesNetFragment< double > *) x));
}
static void *_p_gum__DAGmodelTo_p_gum__GraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphicalModel *)  ((gum::DAGmodel *) x));
}
static void *_p_gum__IBayesNetT_double_tTo_p_gum__GraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphicalModel *) (gum::DAGmodel *) ((gum::IBayesNet< double > *) x));
}
static void *_p_gum__IMarkovRandomFieldT_double_tTo_p_gum__GraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphicalModel *) (gum::UGmodel *) ((gum::IMarkovRandomField< double > *) x));
}
static void *_p_gum__InfluenceDiagramT_double_tTo_p_gum__GraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphicalModel *) (gum::DAGmodel *) ((gum::InfluenceDiagram< double > *) x));
}
static void *_p_gum__MarkovRandomFieldT_double_tTo_p_gum__GraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphicalModel *) (gum::UGmodel *)(gum::IMarkovRandomField< double > *) ((gum::MarkovRandomField< double > *) x));
}
static void *_p_gum__UGmodelTo_p_gum__GraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphicalModel *)  ((gum::UGmodel *) 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::IBNLearner *) ((gum::learning::BNLearner< double > *) x));
}
static void *_p_gum__learning__IBNLearnerTo_p_gum__IApproximationSchemeConfiguration(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::IApproximationSchemeConfiguration *)  ((gum::learning::IBNLearner *) 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__BayesNetFragmentT_double_tTo_p_gum__IBayesNetT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::IBayesNet< double > *)  ((gum::BayesNetFragment< double > *) 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__MarkovRandomFieldT_double_tTo_p_gum__IMarkovRandomFieldT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::IMarkovRandomField< double > *)  ((gum::MarkovRandomField< 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__LoopySamplingInferenceT_double_gum__ImportanceSampling_tTo_p_gum__ImportanceSamplingT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ImportanceSampling< double > *)  ((gum::LoopySamplingInference< double,gum::ImportanceSampling > *) x));
}
static void *_p_gum__UndefinedIteratorKeyTo_p_gum__IteratorError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::IteratorError *)  ((gum::UndefinedIteratorKey *) x));
}
static void *_p_gum__UndefinedIteratorValueTo_p_gum__IteratorError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::IteratorError *)  ((gum::UndefinedIteratorValue *) 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__IncompatibleScorePriorTo_p_gum__LearningError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::LearningError *)  ((gum::IncompatibleScorePrior *) 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__MissingVariableInDatabaseTo_p_gum__LearningError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::LearningError *)  ((gum::MissingVariableInDatabase *) x));
}
static void *_p_gum__PossiblyIncompatibleScorePriorTo_p_gum__LearningError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::LearningError *)  ((gum::PossiblyIncompatibleScorePrior *) x));
}
static void *_p_gum__UnknownLabelInDatabaseTo_p_gum__LearningError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::LearningError *)  ((gum::UnknownLabelInDatabase *) x));
}
static void *_p_PythonBNListenerTo_p_gum__Listener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Listener *) (gum::DiGraphListener *) ((PythonBNListener *) x));
}
static void *_p_PythonLoadListenerTo_p_gum__Listener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Listener *)  ((PythonLoadListener *) x));
}
static void *_p_gum__BayesNetFragmentT_double_tTo_p_gum__Listener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Listener *) (gum::DiGraphListener *) ((gum::BayesNetFragment< double > *) x));
}
static void *_p_gum__DiGraphListenerTo_p_gum__Listener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Listener *)  ((gum::DiGraphListener *) x));
}
static void *_p_gum__PDAGTo_p_gum__MixedGraph(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MixedGraph *)  ((gum::PDAG *) x));
}
static void *_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_tTo_p_gum__MonteCarloSamplingT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MonteCarloSampling< double > *)  ((gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 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__MultiDimContainerT_double_tTo_p_gum__MultiDimAdressable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimAdressable *)  ((gum::MultiDimContainer< 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__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__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__TensorT_double_tTo_p_gum__MultiDimAdressable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimAdressable *) (gum::MultiDimContainer< double > *)(gum::MultiDimDecorator< double > *) ((gum::Tensor< 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__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__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__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__TensorT_double_tTo_p_gum__MultiDimContainerT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimContainer< double > *) (gum::MultiDimDecorator< double > *) ((gum::Tensor< double > *) x));
}
static void *_p_gum__TensorT_double_tTo_p_gum__MultiDimDecoratorT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimDecorator< double > *)  ((gum::Tensor< 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__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__InstantiationTo_p_gum__MultiDimInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimInterface *)  ((gum::Instantiation *) 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__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__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__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__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__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__TensorT_double_tTo_p_gum__MultiDimInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimInterface *) (gum::MultiDimAdressable *)(gum::MultiDimContainer< double > *)(gum::MultiDimDecorator< double > *) ((gum::Tensor< 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__CliqueGraphTo_p_gum__NodeGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::NodeGraphPart *) (gum::UndiGraph *) ((gum::CliqueGraph *) 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__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__PDAGTo_p_gum__NodeGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::NodeGraphPart *) (gum::UndiGraph *)(gum::MixedGraph *) ((gum::PDAG *) 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__AbstractScheduleMultiDimTo_p_gum__ScheduleMultiDimError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ScheduleMultiDimError *)  ((gum::AbstractScheduleMultiDim *) x));
}
static void *_p_gum__DuplicateScheduleMultiDimTo_p_gum__ScheduleMultiDimError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ScheduleMultiDimError *)  ((gum::DuplicateScheduleMultiDim *) x));
}
static void *_p_gum__UnknownScheduleMultiDimTo_p_gum__ScheduleMultiDimError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ScheduleMultiDimError *)  ((gum::UnknownScheduleMultiDim *) x));
}
static void *_p_gum__UnavailableScheduleOperationTo_p_gum__ScheduleOperationError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ScheduleOperationError *)  ((gum::UnavailableScheduleOperation *) x));
}
static void *_p_gum__UnexecutedScheduleOperationTo_p_gum__ScheduleOperationError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ScheduleOperationError *)  ((gum::UnexecutedScheduleOperation *) x));
}
static void *_p_gum__UnknownScheduleOperationTo_p_gum__ScheduleOperationError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ScheduleOperationError *)  ((gum::UnknownScheduleOperation *) x));
}
static void *_p_gum__LazyPropagationT_double_tTo_p_gum__ScheduledInference(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ScheduledInference *)  ((gum::LazyPropagation< double > *) x));
}
static void *_p_gum__ShaferShenoyInferenceT_double_tTo_p_gum__ScheduledInference(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ScheduledInference *)  ((gum::ShaferShenoyInference< double > *) x));
}
static void *_p_gum__ShaferShenoyMRFInferenceT_double_tTo_p_gum__ScheduledInference(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ScheduledInference *)  ((gum::ShaferShenoyMRFInference< double > *) x));
}
static void *_p_gum__VariableEliminationT_double_tTo_p_gum__ScheduledInference(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ScheduledInference *)  ((gum::VariableElimination< double > *) x));
}
static void *_p_gum__LazyPropagationT_double_tTo_p_gum__ThreadNumberManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ThreadNumberManager *) (gum::ScheduledInference *) ((gum::LazyPropagation< double > *) x));
}
static void *_p_gum__ScheduledInferenceTo_p_gum__ThreadNumberManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ThreadNumberManager *)  ((gum::ScheduledInference *) x));
}
static void *_p_gum__ShaferShenoyInferenceT_double_tTo_p_gum__ThreadNumberManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ThreadNumberManager *) (gum::ScheduledInference *) ((gum::ShaferShenoyInference< double > *) x));
}
static void *_p_gum__ShaferShenoyMRFInferenceT_double_tTo_p_gum__ThreadNumberManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ThreadNumberManager *) (gum::ScheduledInference *) ((gum::ShaferShenoyMRFInference< double > *) x));
}
static void *_p_gum__VariableEliminationT_double_tTo_p_gum__ThreadNumberManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ThreadNumberManager *) (gum::ScheduledInference *) ((gum::VariableElimination< double > *) x));
}
static void *_p_gum__learning__BNLearnerT_double_tTo_p_gum__ThreadNumberManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ThreadNumberManager *) (gum::learning::IBNLearner *) ((gum::learning::BNLearner< double > *) x));
}
static void *_p_gum__learning__IBNLearnerTo_p_gum__ThreadNumberManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ThreadNumberManager *)  ((gum::learning::IBNLearner *) x));
}
static void *_p_gum__IMarkovRandomFieldT_double_tTo_p_gum__UGmodel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::UGmodel *)  ((gum::IMarkovRandomField< double > *) x));
}
static void *_p_gum__MarkovRandomFieldT_double_tTo_p_gum__UGmodel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::UGmodel *) (gum::IMarkovRandomField< double > *) ((gum::MarkovRandomField< double > *) 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__UndiGraph(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::UndiGraph *)  ((gum::MixedGraph *) x));
}
static void *_p_gum__PDAGTo_p_gum__UndiGraph(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::UndiGraph *) (gum::MixedGraph *) ((gum::PDAG *) 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__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__IDiscretizedVariableTo_p_gum__Variable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Variable *) (gum::DiscreteVariable *) ((gum::IDiscretizedVariable *) x));
}
static void *_p_gum__IntegerVariableTo_p_gum__Variable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Variable *) (gum::DiscreteVariable *) ((gum::IntegerVariable *) 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__NumericalDiscreteVariableTo_p_gum__Variable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Variable *) (gum::DiscreteVariable *) ((gum::NumericalDiscreteVariable *) 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__LoopySamplingInferenceT_double_gum__WeightedSampling_tTo_p_gum__WeightedSamplingT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::WeightedSampling< double > *)  ((gum::LoopySamplingInference< double,gum::WeightedSampling > *) x));
}
static void *_p_gum__learning__BNLearnerT_double_tTo_p_gum__learning__IBNLearner(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::learning::IBNLearner *)  ((gum::learning::BNLearner< double > *) x));
}
static void *_p_gum__AbstractScheduleMultiDimTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::ScheduleMultiDimError *) ((gum::AbstractScheduleMultiDim *) x));
}
static void *_p_gum__ArgumentErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::ArgumentError *) x));
}
static void *_p_gum__CPTErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::CPTError *) x));
}
static void *_p_gum__DatabaseErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::LearningError *) ((gum::DatabaseError *) x));
}
static void *_p_gum__DefaultInLabelTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::GraphError *) ((gum::DefaultInLabel *) x));
}
static void *_p_gum__DuplicateElementTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::ArgumentError *) ((gum::DuplicateElement *) x));
}
static void *_p_gum__DuplicateLabelTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::ArgumentError *) ((gum::DuplicateLabel *) x));
}
static void *_p_gum__DuplicateScheduleMultiDimTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::ScheduleMultiDimError *) ((gum::DuplicateScheduleMultiDim *) x));
}
static void *_p_gum__ExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *)  ((gum::Exception *) x));
}
static void *_p_gum__FactoryErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::FactoryError *) x));
}
static void *_p_gum__FactoryInvalidStateTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::FactoryError *) ((gum::FactoryInvalidState *) x));
}
static void *_p_gum__FatalErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::FatalError *) x));
}
static void *_p_gum__FormatNotFoundTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::IOError *) ((gum::FormatNotFound *) x));
}
static void *_p_gum__GraphErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::GraphError *) x));
}
static void *_p_gum__IOErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::IOError *) x));
}
static void *_p_gum__IncompatibleEvidenceTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::IncompatibleEvidence *) x));
}
static void *_p_gum__IncompatibleScorePriorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::LearningError *) ((gum::IncompatibleScorePrior *) x));
}
static void *_p_gum__InvalidArcTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::GraphError *) ((gum::InvalidArc *) x));
}
static void *_p_gum__InvalidArgumentTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::ArgumentError *) ((gum::InvalidArgument *) x));
}
static void *_p_gum__InvalidArgumentsNumberTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::ArgumentError *) ((gum::InvalidArgumentsNumber *) x));
}
static void *_p_gum__InvalidDirectedCycleTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::GraphError *) ((gum::InvalidDirectedCycle *) x));
}
static void *_p_gum__InvalidEdgeTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::GraphError *) ((gum::InvalidEdge *) x));
}
static void *_p_gum__InvalidNodeTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::GraphError *) ((gum::InvalidNode *) x));
}
static void *_p_gum__InvalidPartiallyDirectedCycleTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::GraphError *) ((gum::InvalidPartiallyDirectedCycle *) x));
}
static void *_p_gum__IteratorErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::IteratorError *) x));
}
static void *_p_gum__LearningErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::LearningError *) x));
}
static void *_p_gum__MissingValueInDatabaseTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::LearningError *) ((gum::MissingValueInDatabase *) x));
}
static void *_p_gum__MissingVariableInDatabaseTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::LearningError *) ((gum::MissingVariableInDatabase *) x));
}
static void *_p_gum__NoChildTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::GraphError *) ((gum::NoChild *) x));
}
static void *_p_gum__NoNeighbourTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::GraphError *) ((gum::NoNeighbour *) x));
}
static void *_p_gum__NoParentTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::GraphError *) ((gum::NoParent *) x));
}
static void *_p_gum__NotFoundTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::NotFound *) x));
}
static void *_p_gum__NotImplementedYetTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::NotImplementedYet *) x));
}
static void *_p_gum__NullElementTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::NullElement *) x));
}
static void *_p_gum__OperationNotAllowedTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::OperationNotAllowed *) x));
}
static void *_p_gum__OutOfBoundsTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::ArgumentError *) ((gum::OutOfBounds *) x));
}
static void *_p_gum__PRMTypeErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::FactoryError *) ((gum::PRMTypeError *) x));
}
static void *_p_gum__PossiblyIncompatibleScorePriorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::LearningError *) ((gum::PossiblyIncompatibleScorePrior *) x));
}
static void *_p_gum__ScheduleMultiDimErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::ScheduleMultiDimError *) x));
}
static void *_p_gum__ScheduleOperationErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::ScheduleOperationError *) x));
}
static void *_p_gum__SizeErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::SizeError *) x));
}
static void *_p_gum__SyntaxErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::IOError *) ((gum::SyntaxError *) x));
}
static void *_p_gum__TypeErrorTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::FactoryError *) ((gum::TypeError *) x));
}
static void *_p_gum__UnavailableScheduleOperationTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::ScheduleOperationError *) ((gum::UnavailableScheduleOperation *) x));
}
static void *_p_gum__UndefinedElementTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::UndefinedElement *) x));
}
static void *_p_gum__UndefinedIteratorKeyTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::IteratorError *) ((gum::UndefinedIteratorKey *) x));
}
static void *_p_gum__UndefinedIteratorValueTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::IteratorError *) ((gum::UndefinedIteratorValue *) x));
}
static void *_p_gum__UnexecutedScheduleOperationTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::ScheduleOperationError *) ((gum::UnexecutedScheduleOperation *) x));
}
static void *_p_gum__UnknownLabelInDatabaseTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::LearningError *) ((gum::UnknownLabelInDatabase *) x));
}
static void *_p_gum__UnknownScheduleMultiDimTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::ScheduleMultiDimError *) ((gum::UnknownScheduleMultiDim *) x));
}
static void *_p_gum__UnknownScheduleOperationTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::ScheduleOperationError *) ((gum::UnknownScheduleOperation *) x));
}
static void *_p_gum__WrongClassElementTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *)(gum::FactoryError *) ((gum::WrongClassElement *) 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_Handler = {"_p_Handler", "Handler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandlerSafe = {"_p_HandlerSafe", "HandlerSafe *", 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_InformationTheory = {"_p_InformationTheory", "InformationTheory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IsMissing = {"_p_IsMissing", "IsMissing *", 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_MissingValType = {"_p_MissingValType", "MissingValType *", 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_first_type = {"_p_first_type", "first_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__AbstractScheduleMultiDim = {"_p_gum__AbstractScheduleMultiDim", "gum::AbstractScheduleMultiDim *", 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__ArgumentError = {"_p_gum__ArgumentError", "gum::ArgumentError *", 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__BayesNetFragmentT_double_t = {"_p_gum__BayesNetFragmentT_double_t", "gum::BayesNetFragment< 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__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__DiGraphListener = {"_p_gum__DiGraphListener", "gum::DiGraphListener *", 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__DuplicateScheduleMultiDim = {"_p_gum__DuplicateScheduleMultiDim", "gum::DuplicateScheduleMultiDim *", 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__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__GraphicalModel = {"_p_gum__GraphicalModel", "gum::GraphicalModel *", 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__IMarkovRandomFieldT_double_t = {"_p_gum__IMarkovRandomFieldT_double_t", "gum::IMarkovRandomField< double > *", 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__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__IncompatibleScorePrior = {"_p_gum__IncompatibleScorePrior", "gum::IncompatibleScorePrior *", 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__IntegerVariable = {"_p_gum__IntegerVariable", "gum::IntegerVariable *", 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__InvalidPartiallyDirectedCycle = {"_p_gum__InvalidPartiallyDirectedCycle", "gum::InvalidPartiallyDirectedCycle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__IteratorError = {"_p_gum__IteratorError", "gum::IteratorError *", 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__ListConstIteratorSafeT_Debug_t = {"_p_gum__ListConstIteratorSafeT_Debug_t", "gum::ListConstIteratorSafe< Debug > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__ListConstIteratorT_Debug_t = {"_p_gum__ListConstIteratorT_Debug_t", "gum::ListConstIterator< Debug > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__Listener = {"_p_gum__Listener", "gum::Listener *", 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__MarkovRandomFieldT_double_t = {"_p_gum__MarkovRandomFieldT_double_t", "gum::MarkovRandomField< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__MeekRules = {"_p_gum__MeekRules", "gum::MeekRules *", 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_std__size_t_t = {"_p_gum__NodePropertyT_std__size_t_t", "gum::NodeProperty< gum::NodeId > *|gum::NodeProperty< std::size_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_t_t_t = {"_p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_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__NumericalDiscreteVariable = {"_p_gum__NumericalDiscreteVariable", "gum::NumericalDiscreteVariable *", 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__PDAG = {"_p_gum__PDAG", "gum::PDAG *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__PRMTypeError = {"_p_gum__PRMTypeError", "gum::PRMTypeError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__PossiblyIncompatibleScorePrior = {"_p_gum__PossiblyIncompatibleScorePrior", "gum::PossiblyIncompatibleScorePrior *", 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__ScheduleMultiDimError = {"_p_gum__ScheduleMultiDimError", "gum::ScheduleMultiDimError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__ScheduleOperationError = {"_p_gum__ScheduleOperationError", "gum::ScheduleOperationError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__ScheduledInference = {"_p_gum__ScheduledInference", "gum::ScheduledInference *", 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__SetIteratorSafeT_int_t = {"_p_gum__SetIteratorSafeT_int_t", "gum::SetIteratorSafe< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SetIteratorT_int_t = {"_p_gum__SetIteratorT_int_t", "gum::SetIterator< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SetT_gum__Arc_t = {"_p_gum__SetT_gum__Arc_t", "gum::ArcSet *|gum::Set< gum::Arc > *", 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::ArcSetIterator *|gum::Set< gum::Arc >::const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SetT_gum__DiscreteVariable_const_p_t = {"_p_gum__SetT_gum__DiscreteVariable_const_p_t", "gum::VariableSet *|gum::Set< gum::DiscreteVariable const * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SetT_gum__Edge_t = {"_p_gum__SetT_gum__Edge_t", "gum::EdgeSet *|gum::Set< gum::Edge > *", 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::EdgeSetIterator *|gum::Set< gum::Edge >::const_iterator *", 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::NodeSet *|gum::Set< std::size_t > *", 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::NodeSetIterator *|gum::Set< std::size_t >::const_iterator *", 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__ShaferShenoyLIMIDInferenceT_double_t = {"_p_gum__ShaferShenoyLIMIDInferenceT_double_t", "gum::ShaferShenoyLIMIDInference< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__ShaferShenoyMRFInferenceT_double_t = {"_p_gum__ShaferShenoyMRFInferenceT_double_t", "gum::ShaferShenoyMRFInference< 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__TensorT_double_t = {"_p_gum__TensorT_double_t", "gum::Tensor< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__ThreadNumberManager = {"_p_gum__ThreadNumberManager", "gum::ThreadNumberManager *", 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__UGmodel = {"_p_gum__UGmodel", "gum::UGmodel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__UnavailableScheduleOperation = {"_p_gum__UnavailableScheduleOperation", "gum::UnavailableScheduleOperation *", 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__UnexecutedScheduleOperation = {"_p_gum__UnexecutedScheduleOperation", "gum::UnexecutedScheduleOperation *", 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__UnknownScheduleMultiDim = {"_p_gum__UnknownScheduleMultiDim", "gum::UnknownScheduleMultiDim *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__UnknownScheduleOperation = {"_p_gum__UnknownScheduleOperation", "gum::UnknownScheduleOperation *", 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__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_t = {"_p_gum__credal__CNMonteCarloSamplingT_double_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__DatabaseTable = {"_p_gum__learning__DatabaseTable", "gum::learning::DatabaseTable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__learning__IBNLearner = {"_p_gum__learning__IBNLearner", "gum::learning::IBNLearner *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iterator = {"_p_iterator", "iterator *", 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_iterator_safe = {"_p_iterator_safe", "iterator_safe *", 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_second_type = {"_p_second_type", "second_type *", 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_int_t = {"_p_std__allocatorT_int_t", "std::vector< int >::allocator_type *|std::allocator< int > *", 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__exception = {"_p_std__exception", "std::exception *", 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__functionT_double_fgum__Instantiation_const_RF_t = {"_p_std__functionT_double_fgum__Instantiation_const_RF_t", "std::function< double (gum::Instantiation const &) > *", 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__mt19937 = {"_p_std__mt19937", "std::mt19937 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_gum__Instantiation_double_t = {"_p_std__pairT_gum__Instantiation_double_t", "std::pair< gum::Instantiation,double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__size_t = {"_p_std__size_t", "gum::Idx *|gum::NodeId *|gum::Size *|std::size_t *", 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_t = {"_p_std__vectorT_double_t", "std::vector< double,std::allocator< double > > *|std::vector< double > *", 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_gum__SetT_std__size_t_t_std__allocatorT_gum__SetT_std__size_t_t_t_t = {"_p_std__vectorT_gum__SetT_std__size_t_t_std__allocatorT_gum__SetT_std__size_t_t_t_t", "std::vector< gum::NodeSet,std::allocator< gum::NodeSet > > *|std::vector< gum::Set< std::size_t >,std::allocator< gum::Set< std::size_t > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_int_t = {"_p_std__vectorT_int_t", "std::vector< int,std::allocator< int > > *|std::vector< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__size_t_std__size_t_t_std__allocatorT_std__pairT_std__size_t_std__size_t_t_t_t = {"_p_std__vectorT_std__pairT_std__size_t_std__size_t_t_std__allocatorT_std__pairT_std__size_t_std__size_t_t_t_t", "std::vector< std::pair< gum::Idx,gum::Idx >,std::allocator< std::pair< gum::Idx,gum::Idx > > > *|std::vector< std::pair< std::size_t,std::size_t >,std::allocator< std::pair< std::size_t,std::size_t > > > *", 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::Idx,std::allocator< gum::Idx > > *|std::vector< gum::NodeId,std::allocator< gum::NodeId > > *|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_t = {"_p_std__vectorT_std__string_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_t_std__allocatorT_std__vectorT_double_t_t_t = {"_p_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_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__string_t_std__allocatorT_std__vectorT_std__string_t_t_t = {"_p_std__vectorT_std__vectorT_std__string_t_std__allocatorT_std__vectorT_std__string_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_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_t_t = {"_p_std__vectorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_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_t = {"_p_std__vectorT_unsigned_int_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_Handler,
  &_swigt__p_HandlerSafe,
  &_swigt__p_IDGenerator,
  &_swigt__p_InformationTheory,
  &_swigt__p_IsMissing,
  &_swigt__p_JunctionTreeGenerator,
  &_swigt__p_MissingValType,
  &_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_first_type,
  &_swigt__p_gum__AbstractScheduleMultiDim,
  &_swigt__p_gum__ApproximationScheme,
  &_swigt__p_gum__Arc,
  &_swigt__p_gum__ArcGraphPart,
  &_swigt__p_gum__ArgumentError,
  &_swigt__p_gum__BNdistanceT_double_t,
  &_swigt__p_gum__BayesNetFragmentT_double_t,
  &_swigt__p_gum__BayesNetT_double_t,
  &_swigt__p_gum__CPTError,
  &_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__DiGraphListener,
  &_swigt__p_gum__DiscreteVariable,
  &_swigt__p_gum__DiscretizedVariableT_double_t,
  &_swigt__p_gum__DuplicateElement,
  &_swigt__p_gum__DuplicateLabel,
  &_swigt__p_gum__DuplicateScheduleMultiDim,
  &_swigt__p_gum__Edge,
  &_swigt__p_gum__EdgeGraphPart,
  &_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__GraphicalModel,
  &_swigt__p_gum__IApproximationSchemeConfiguration,
  &_swigt__p_gum__IBayesNetT_double_t,
  &_swigt__p_gum__IDiscretizedVariable,
  &_swigt__p_gum__IMarkovRandomFieldT_double_t,
  &_swigt__p_gum__IOError,
  &_swigt__p_gum__ImportanceSamplingT_double_t,
  &_swigt__p_gum__IncompatibleEvidence,
  &_swigt__p_gum__IncompatibleScorePrior,
  &_swigt__p_gum__InfluenceDiagramT_double_t,
  &_swigt__p_gum__Instantiation,
  &_swigt__p_gum__IntegerVariable,
  &_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__InvalidPartiallyDirectedCycle,
  &_swigt__p_gum__IteratorError,
  &_swigt__p_gum__LabelizedVariable,
  &_swigt__p_gum__LazyPropagationT_double_t,
  &_swigt__p_gum__LearningError,
  &_swigt__p_gum__ListConstIteratorSafeT_Debug_t,
  &_swigt__p_gum__ListConstIteratorT_Debug_t,
  &_swigt__p_gum__Listener,
  &_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__MarkovRandomFieldT_double_t,
  &_swigt__p_gum__MeekRules,
  &_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_std__size_t_t,
  &_swigt__p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_t_t_t,
  &_swigt__p_gum__NotFound,
  &_swigt__p_gum__NotImplementedYet,
  &_swigt__p_gum__NullElement,
  &_swigt__p_gum__NumericalDiscreteVariable,
  &_swigt__p_gum__OperationNotAllowed,
  &_swigt__p_gum__OutOfBounds,
  &_swigt__p_gum__PDAG,
  &_swigt__p_gum__PRMTypeError,
  &_swigt__p_gum__PossiblyIncompatibleScorePrior,
  &_swigt__p_gum__RangeVariable,
  &_swigt__p_gum__ScheduleMultiDimError,
  &_swigt__p_gum__ScheduleOperationError,
  &_swigt__p_gum__ScheduledInference,
  &_swigt__p_gum__SequenceT_gum__DiscreteVariable_const_p_t,
  &_swigt__p_gum__SequenceT_std__size_t_t,
  &_swigt__p_gum__SetIteratorSafeT_int_t,
  &_swigt__p_gum__SetIteratorT_int_t,
  &_swigt__p_gum__SetT_gum__Arc_t,
  &_swigt__p_gum__SetT_gum__Arc_t__const_iterator,
  &_swigt__p_gum__SetT_gum__DiscreteVariable_const_p_t,
  &_swigt__p_gum__SetT_gum__Edge_t,
  &_swigt__p_gum__SetT_gum__Edge_t__const_iterator,
  &_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__ShaferShenoyLIMIDInferenceT_double_t,
  &_swigt__p_gum__ShaferShenoyMRFInferenceT_double_t,
  &_swigt__p_gum__SizeError,
  &_swigt__p_gum__StructuralComparator,
  &_swigt__p_gum__SyntaxError,
  &_swigt__p_gum__TensorT_double_t,
  &_swigt__p_gum__ThreadNumberManager,
  &_swigt__p_gum__Triangulation,
  &_swigt__p_gum__TypeError,
  &_swigt__p_gum__UGmodel,
  &_swigt__p_gum__UnavailableScheduleOperation,
  &_swigt__p_gum__UndefinedElement,
  &_swigt__p_gum__UndefinedIteratorKey,
  &_swigt__p_gum__UndefinedIteratorValue,
  &_swigt__p_gum__UndiGraph,
  &_swigt__p_gum__UnexecutedScheduleOperation,
  &_swigt__p_gum__UnknownLabelInDatabase,
  &_swigt__p_gum__UnknownScheduleMultiDim,
  &_swigt__p_gum__UnknownScheduleOperation,
  &_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__credal__CNLoopyPropagationT_double_t,
  &_swigt__p_gum__credal__CNMonteCarloSamplingT_double_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__DatabaseTable,
  &_swigt__p_gum__learning__IBNLearner,
  &_swigt__p_iterator,
  &_swigt__p_iterator_category,
  &_swigt__p_iterator_safe,
  &_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_second_type,
  &_swigt__p_size_type,
  &_swigt__p_std__allocatorT_double_t,
  &_swigt__p_std__allocatorT_int_t,
  &_swigt__p_std__allocatorT_std__string_t,
  &_swigt__p_std__allocatorT_unsigned_int_t,
  &_swigt__p_std__exception,
  &_swigt__p_std__functionT_double_fdoubleF_t,
  &_swigt__p_std__functionT_double_fdouble_doubleF_t,
  &_swigt__p_std__functionT_double_fgum__Instantiation_const_RF_t,
  &_swigt__p_std__invalid_argument,
  &_swigt__p_std__mt19937,
  &_swigt__p_std__pairT_gum__Instantiation_double_t,
  &_swigt__p_std__size_t,
  &_swigt__p_std__string,
  &_swigt__p_std__vectorT_PythonLoadListener_std__allocatorT_PythonLoadListener_t_t,
  &_swigt__p_std__vectorT_double_t,
  &_swigt__p_std__vectorT_gum__DiscreteVariable_const_p_std__allocatorT_gum__DiscreteVariable_const_p_t_t,
  &_swigt__p_std__vectorT_gum__SetT_std__size_t_t_std__allocatorT_gum__SetT_std__size_t_t_t_t,
  &_swigt__p_std__vectorT_int_t,
  &_swigt__p_std__vectorT_std__pairT_std__size_t_std__size_t_t_std__allocatorT_std__pairT_std__size_t_std__size_t_t_t_t,
  &_swigt__p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t,
  &_swigt__p_std__vectorT_std__string_t,
  &_swigt__p_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_std__string_t_std__allocatorT_std__vectorT_std__string_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_t_t,
  &_swigt__p_std__vectorT_unsigned_int_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_Handler[] = {  {&_swigt__p_Handler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandlerSafe[] = {  {&_swigt__p_HandlerSafe, 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_InformationTheory[] = {  {&_swigt__p_InformationTheory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IsMissing[] = {  {&_swigt__p_IsMissing, 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_MissingValType[] = {  {&_swigt__p_MissingValType, 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_first_type[] = {  {&_swigt__p_first_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__AbstractScheduleMultiDim[] = {  {&_swigt__p_gum__AbstractScheduleMultiDim, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__ApproximationScheme[] = {  {&_swigt__p_gum__ApproximationScheme, 0, 0, 0},  {&_swigt__p_gum__GibbsBNdistanceT_double_t, _p_gum__GibbsBNdistanceT_double_tTo_p_gum__ApproximationScheme, 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__ArcGraphPart, 0, 0, 0},  {&_swigt__p_gum__DAG, _p_gum__DAGTo_p_gum__ArcGraphPart, 0, 0},  {&_swigt__p_gum__DiGraph, _p_gum__DiGraphTo_p_gum__ArcGraphPart, 0, 0},  {&_swigt__p_gum__MixedGraph, _p_gum__MixedGraphTo_p_gum__ArcGraphPart, 0, 0},  {&_swigt__p_gum__PDAG, _p_gum__PDAGTo_p_gum__ArcGraphPart, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__ArgumentError[] = {  {&_swigt__p_gum__ArgumentError, 0, 0, 0},  {&_swigt__p_gum__DuplicateElement, _p_gum__DuplicateElementTo_p_gum__ArgumentError, 0, 0},  {&_swigt__p_gum__DuplicateLabel, _p_gum__DuplicateLabelTo_p_gum__ArgumentError, 0, 0},  {&_swigt__p_gum__InvalidArgument, _p_gum__InvalidArgumentTo_p_gum__ArgumentError, 0, 0},  {&_swigt__p_gum__InvalidArgumentsNumber, _p_gum__InvalidArgumentsNumberTo_p_gum__ArgumentError, 0, 0},  {&_swigt__p_gum__OutOfBounds, _p_gum__OutOfBoundsTo_p_gum__ArgumentError, 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__BayesNetFragmentT_double_t[] = {  {&_swigt__p_gum__BayesNetFragmentT_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__CPTError, 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__BayesNetFragmentT_double_t, _p_gum__BayesNetFragmentT_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__IBayesNetT_double_t, _p_gum__IBayesNetT_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},  {&_swigt__p_gum__PDAG, _p_gum__PDAGTo_p_gum__DiGraph, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__DiGraphListener[] = {  {&_swigt__p_gum__DiGraphListener, 0, 0, 0},  {&_swigt__p_PythonBNListener, _p_PythonBNListenerTo_p_gum__DiGraphListener, 0, 0},  {&_swigt__p_gum__BayesNetFragmentT_double_t, _p_gum__BayesNetFragmentT_double_tTo_p_gum__DiGraphListener, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__DiscreteVariable[] = {  {&_swigt__p_gum__DiscreteVariable, 0, 0, 0},  {&_swigt__p_gum__DiscretizedVariableT_double_t, _p_gum__DiscretizedVariableT_double_tTo_p_gum__DiscreteVariable, 0, 0},  {&_swigt__p_gum__IDiscretizedVariable, _p_gum__IDiscretizedVariableTo_p_gum__DiscreteVariable, 0, 0},  {&_swigt__p_gum__IntegerVariable, _p_gum__IntegerVariableTo_p_gum__DiscreteVariable, 0, 0},  {&_swigt__p_gum__LabelizedVariable, _p_gum__LabelizedVariableTo_p_gum__DiscreteVariable, 0, 0},  {&_swigt__p_gum__NumericalDiscreteVariable, _p_gum__NumericalDiscreteVariableTo_p_gum__DiscreteVariable, 0, 0},  {&_swigt__p_gum__RangeVariable, _p_gum__RangeVariableTo_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__DuplicateScheduleMultiDim[] = {  {&_swigt__p_gum__DuplicateScheduleMultiDim, 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__EdgeGraphPart, 0, 0, 0},  {&_swigt__p_gum__CliqueGraph, _p_gum__CliqueGraphTo_p_gum__EdgeGraphPart, 0, 0},  {&_swigt__p_gum__MixedGraph, _p_gum__MixedGraphTo_p_gum__EdgeGraphPart, 0, 0},  {&_swigt__p_gum__PDAG, _p_gum__PDAGTo_p_gum__EdgeGraphPart, 0, 0},  {&_swigt__p_gum__UndiGraph, _p_gum__UndiGraphTo_p_gum__EdgeGraphPart, 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__Exception, 0, 0, 0},  {&_swigt__p_gum__AbstractScheduleMultiDim, _p_gum__AbstractScheduleMultiDimTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__ArgumentError, _p_gum__ArgumentErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__CPTError, _p_gum__CPTErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__DatabaseError, _p_gum__DatabaseErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__DefaultInLabel, _p_gum__DefaultInLabelTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__DuplicateElement, _p_gum__DuplicateElementTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__DuplicateLabel, _p_gum__DuplicateLabelTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__DuplicateScheduleMultiDim, _p_gum__DuplicateScheduleMultiDimTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__FactoryError, _p_gum__FactoryErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__FactoryInvalidState, _p_gum__FactoryInvalidStateTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__FatalError, _p_gum__FatalErrorTo_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__IOError, _p_gum__IOErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__IncompatibleEvidence, _p_gum__IncompatibleEvidenceTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__IncompatibleScorePrior, _p_gum__IncompatibleScorePriorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__InvalidArc, _p_gum__InvalidArcTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__InvalidArgument, _p_gum__InvalidArgumentTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__InvalidArgumentsNumber, _p_gum__InvalidArgumentsNumberTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__InvalidDirectedCycle, _p_gum__InvalidDirectedCycleTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__InvalidEdge, _p_gum__InvalidEdgeTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__InvalidNode, _p_gum__InvalidNodeTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__InvalidPartiallyDirectedCycle, _p_gum__InvalidPartiallyDirectedCycleTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__IteratorError, _p_gum__IteratorErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__LearningError, _p_gum__LearningErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__MissingValueInDatabase, _p_gum__MissingValueInDatabaseTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__MissingVariableInDatabase, _p_gum__MissingVariableInDatabaseTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__NoChild, _p_gum__NoChildTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__NoNeighbour, _p_gum__NoNeighbourTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__NoParent, _p_gum__NoParentTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__NotFound, _p_gum__NotFoundTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__NotImplementedYet, _p_gum__NotImplementedYetTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__NullElement, _p_gum__NullElementTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__OperationNotAllowed, _p_gum__OperationNotAllowedTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__OutOfBounds, _p_gum__OutOfBoundsTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__PRMTypeError, _p_gum__PRMTypeErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__PossiblyIncompatibleScorePrior, _p_gum__PossiblyIncompatibleScorePriorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__ScheduleMultiDimError, _p_gum__ScheduleMultiDimErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__ScheduleOperationError, _p_gum__ScheduleOperationErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__SizeError, _p_gum__SizeErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__SyntaxError, _p_gum__SyntaxErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__TypeError, _p_gum__TypeErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__UnavailableScheduleOperation, _p_gum__UnavailableScheduleOperationTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__UndefinedElement, _p_gum__UndefinedElementTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__UndefinedIteratorKey, _p_gum__UndefinedIteratorKeyTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__UndefinedIteratorValue, _p_gum__UndefinedIteratorValueTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__UnexecutedScheduleOperation, _p_gum__UnexecutedScheduleOperationTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__UnknownLabelInDatabase, _p_gum__UnknownLabelInDatabaseTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__UnknownScheduleMultiDim, _p_gum__UnknownScheduleMultiDimTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__UnknownScheduleOperation, _p_gum__UnknownScheduleOperationTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__WrongClassElement, _p_gum__WrongClassElementTo_p_gum__Exception, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__FactoryError[] = {  {&_swigt__p_gum__FactoryError, 0, 0, 0},  {&_swigt__p_gum__FactoryInvalidState, _p_gum__FactoryInvalidStateTo_p_gum__FactoryError, 0, 0},  {&_swigt__p_gum__PRMTypeError, _p_gum__PRMTypeErrorTo_p_gum__FactoryError, 0, 0},  {&_swigt__p_gum__TypeError, _p_gum__TypeErrorTo_p_gum__FactoryError, 0, 0},  {&_swigt__p_gum__WrongClassElement, _p_gum__WrongClassElementTo_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},  {&_swigt__p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, _p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_tTo_p_gum__GibbsSamplingT_double_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__GraphError[] = {  {&_swigt__p_gum__GraphError, 0, 0, 0},  {&_swigt__p_gum__DefaultInLabel, _p_gum__DefaultInLabelTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__InvalidArc, _p_gum__InvalidArcTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__InvalidDirectedCycle, _p_gum__InvalidDirectedCycleTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__InvalidEdge, _p_gum__InvalidEdgeTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__InvalidNode, _p_gum__InvalidNodeTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__InvalidPartiallyDirectedCycle, _p_gum__InvalidPartiallyDirectedCycleTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__NoChild, _p_gum__NoChildTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__NoNeighbour, _p_gum__NoNeighbourTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__NoParent, _p_gum__NoParentTo_p_gum__GraphError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__GraphicalModel[] = {  {&_swigt__p_gum__GraphicalModel, 0, 0, 0},  {&_swigt__p_gum__BayesNetFragmentT_double_t, _p_gum__BayesNetFragmentT_double_tTo_p_gum__GraphicalModel, 0, 0},  {&_swigt__p_gum__BayesNetT_double_t, _p_gum__BayesNetT_double_tTo_p_gum__GraphicalModel, 0, 0},  {&_swigt__p_gum__DAGmodel, _p_gum__DAGmodelTo_p_gum__GraphicalModel, 0, 0},  {&_swigt__p_gum__IBayesNetT_double_t, _p_gum__IBayesNetT_double_tTo_p_gum__GraphicalModel, 0, 0},  {&_swigt__p_gum__IMarkovRandomFieldT_double_t, _p_gum__IMarkovRandomFieldT_double_tTo_p_gum__GraphicalModel, 0, 0},  {&_swigt__p_gum__InfluenceDiagramT_double_t, _p_gum__InfluenceDiagramT_double_tTo_p_gum__GraphicalModel, 0, 0},  {&_swigt__p_gum__MarkovRandomFieldT_double_t, _p_gum__MarkovRandomFieldT_double_tTo_p_gum__GraphicalModel, 0, 0},  {&_swigt__p_gum__UGmodel, _p_gum__UGmodelTo_p_gum__GraphicalModel, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__IApproximationSchemeConfiguration[] = {  {&_swigt__p_gum__IApproximationSchemeConfiguration, 0, 0, 0},  {&_swigt__p_gum__ApproximationScheme, _p_gum__ApproximationSchemeTo_p_gum__IApproximationSchemeConfiguration, 0, 0},  {&_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__learning__IBNLearner, _p_gum__learning__IBNLearnerTo_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__BayesNetFragmentT_double_t, _p_gum__BayesNetFragmentT_double_tTo_p_gum__IBayesNetT_double_t, 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__IMarkovRandomFieldT_double_t[] = {  {&_swigt__p_gum__IMarkovRandomFieldT_double_t, 0, 0, 0},  {&_swigt__p_gum__MarkovRandomFieldT_double_t, _p_gum__MarkovRandomFieldT_double_tTo_p_gum__IMarkovRandomFieldT_double_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__IOError[] = {  {&_swigt__p_gum__IOError, 0, 0, 0},  {&_swigt__p_gum__FormatNotFound, _p_gum__FormatNotFoundTo_p_gum__IOError, 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__ImportanceSamplingT_double_t[] = {  {&_swigt__p_gum__ImportanceSamplingT_double_t, 0, 0, 0},  {&_swigt__p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, _p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_tTo_p_gum__ImportanceSamplingT_double_t, 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__IncompatibleScorePrior[] = {  {&_swigt__p_gum__IncompatibleScorePrior, 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__IntegerVariable[] = {  {&_swigt__p_gum__IntegerVariable, 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__InvalidPartiallyDirectedCycle[] = {  {&_swigt__p_gum__InvalidPartiallyDirectedCycle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__IteratorError[] = {  {&_swigt__p_gum__IteratorError, 0, 0, 0},  {&_swigt__p_gum__UndefinedIteratorKey, _p_gum__UndefinedIteratorKeyTo_p_gum__IteratorError, 0, 0},  {&_swigt__p_gum__UndefinedIteratorValue, _p_gum__UndefinedIteratorValueTo_p_gum__IteratorError, 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__LearningError, 0, 0, 0},  {&_swigt__p_gum__DatabaseError, _p_gum__DatabaseErrorTo_p_gum__LearningError, 0, 0},  {&_swigt__p_gum__IncompatibleScorePrior, _p_gum__IncompatibleScorePriorTo_p_gum__LearningError, 0, 0},  {&_swigt__p_gum__MissingValueInDatabase, _p_gum__MissingValueInDatabaseTo_p_gum__LearningError, 0, 0},  {&_swigt__p_gum__MissingVariableInDatabase, _p_gum__MissingVariableInDatabaseTo_p_gum__LearningError, 0, 0},  {&_swigt__p_gum__PossiblyIncompatibleScorePrior, _p_gum__PossiblyIncompatibleScorePriorTo_p_gum__LearningError, 0, 0},  {&_swigt__p_gum__UnknownLabelInDatabase, _p_gum__UnknownLabelInDatabaseTo_p_gum__LearningError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__ListConstIteratorSafeT_Debug_t[] = {  {&_swigt__p_gum__ListConstIteratorSafeT_Debug_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__ListConstIteratorT_Debug_t[] = {  {&_swigt__p_gum__ListConstIteratorT_Debug_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__Listener[] = {  {&_swigt__p_gum__Listener, 0, 0, 0},  {&_swigt__p_PythonBNListener, _p_PythonBNListenerTo_p_gum__Listener, 0, 0},  {&_swigt__p_PythonLoadListener, _p_PythonLoadListenerTo_p_gum__Listener, 0, 0},  {&_swigt__p_gum__BayesNetFragmentT_double_t, _p_gum__BayesNetFragmentT_double_tTo_p_gum__Listener, 0, 0},  {&_swigt__p_gum__DiGraphListener, _p_gum__DiGraphListenerTo_p_gum__Listener, 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__MarkovRandomFieldT_double_t[] = {  {&_swigt__p_gum__MarkovRandomFieldT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__MeekRules[] = {  {&_swigt__p_gum__MeekRules, 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},  {&_swigt__p_gum__PDAG, _p_gum__PDAGTo_p_gum__MixedGraph, 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},  {&_swigt__p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, _p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_tTo_p_gum__MonteCarloSamplingT_double_t, 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__MultiDimArrayT_double_t, _p_gum__MultiDimArrayT_double_tTo_p_gum__MultiDimAdressable, 0, 0},  {&_swigt__p_gum__MultiDimContainerT_double_t, _p_gum__MultiDimContainerT_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__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__TensorT_double_t, _p_gum__TensorT_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__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__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__TensorT_double_t, _p_gum__TensorT_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__TensorT_double_t, _p_gum__TensorT_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__MultiDimArrayT_double_t, _p_gum__MultiDimArrayT_double_tTo_p_gum__MultiDimImplementationT_double_t, 0, 0},  {&_swigt__p_gum__MultiDimWithOffsetT_double_t, _p_gum__MultiDimWithOffsetT_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__Instantiation, _p_gum__InstantiationTo_p_gum__MultiDimInterface, 0, 0},  {&_swigt__p_gum__MultiDimAdressable, _p_gum__MultiDimAdressableTo_p_gum__MultiDimInterface, 0, 0},  {&_swigt__p_gum__MultiDimArrayT_double_t, _p_gum__MultiDimArrayT_double_tTo_p_gum__MultiDimInterface, 0, 0},  {&_swigt__p_gum__MultiDimContainerT_double_t, _p_gum__MultiDimContainerT_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__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__TensorT_double_t, _p_gum__TensorT_double_tTo_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__NodeGraphPart, 0, 0, 0},  {&_swigt__p_gum__CliqueGraph, _p_gum__CliqueGraphTo_p_gum__NodeGraphPart, 0, 0},  {&_swigt__p_gum__DAG, _p_gum__DAGTo_p_gum__NodeGraphPart, 0, 0},  {&_swigt__p_gum__DiGraph, _p_gum__DiGraphTo_p_gum__NodeGraphPart, 0, 0},  {&_swigt__p_gum__MixedGraph, _p_gum__MixedGraphTo_p_gum__NodeGraphPart, 0, 0},  {&_swigt__p_gum__PDAG, _p_gum__PDAGTo_p_gum__NodeGraphPart, 0, 0},  {&_swigt__p_gum__UndiGraph, _p_gum__UndiGraphTo_p_gum__NodeGraphPart, 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_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_t_t_t[] = {  {&_swigt__p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_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__NumericalDiscreteVariable[] = {  {&_swigt__p_gum__NumericalDiscreteVariable, 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__OutOfBounds, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__PDAG[] = {  {&_swigt__p_gum__PDAG, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__PRMTypeError[] = {  {&_swigt__p_gum__PRMTypeError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__PossiblyIncompatibleScorePrior[] = {  {&_swigt__p_gum__PossiblyIncompatibleScorePrior, 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__ScheduleMultiDimError[] = {  {&_swigt__p_gum__ScheduleMultiDimError, 0, 0, 0},  {&_swigt__p_gum__AbstractScheduleMultiDim, _p_gum__AbstractScheduleMultiDimTo_p_gum__ScheduleMultiDimError, 0, 0},  {&_swigt__p_gum__DuplicateScheduleMultiDim, _p_gum__DuplicateScheduleMultiDimTo_p_gum__ScheduleMultiDimError, 0, 0},  {&_swigt__p_gum__UnknownScheduleMultiDim, _p_gum__UnknownScheduleMultiDimTo_p_gum__ScheduleMultiDimError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__ScheduleOperationError[] = {  {&_swigt__p_gum__ScheduleOperationError, 0, 0, 0},  {&_swigt__p_gum__UnavailableScheduleOperation, _p_gum__UnavailableScheduleOperationTo_p_gum__ScheduleOperationError, 0, 0},  {&_swigt__p_gum__UnexecutedScheduleOperation, _p_gum__UnexecutedScheduleOperationTo_p_gum__ScheduleOperationError, 0, 0},  {&_swigt__p_gum__UnknownScheduleOperation, _p_gum__UnknownScheduleOperationTo_p_gum__ScheduleOperationError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__ScheduledInference[] = {  {&_swigt__p_gum__ScheduledInference, 0, 0, 0},  {&_swigt__p_gum__LazyPropagationT_double_t, _p_gum__LazyPropagationT_double_tTo_p_gum__ScheduledInference, 0, 0},  {&_swigt__p_gum__ShaferShenoyInferenceT_double_t, _p_gum__ShaferShenoyInferenceT_double_tTo_p_gum__ScheduledInference, 0, 0},  {&_swigt__p_gum__ShaferShenoyMRFInferenceT_double_t, _p_gum__ShaferShenoyMRFInferenceT_double_tTo_p_gum__ScheduledInference, 0, 0},  {&_swigt__p_gum__VariableEliminationT_double_t, _p_gum__VariableEliminationT_double_tTo_p_gum__ScheduledInference, 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__SetIteratorSafeT_int_t[] = {  {&_swigt__p_gum__SetIteratorSafeT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__SetIteratorT_int_t[] = {  {&_swigt__p_gum__SetIteratorT_int_t, 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__DiscreteVariable_const_p_t[] = {  {&_swigt__p_gum__SetT_gum__DiscreteVariable_const_p_t, 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_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__ShaferShenoyLIMIDInferenceT_double_t[] = {  {&_swigt__p_gum__ShaferShenoyLIMIDInferenceT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__ShaferShenoyMRFInferenceT_double_t[] = {  {&_swigt__p_gum__ShaferShenoyMRFInferenceT_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__TensorT_double_t[] = {  {&_swigt__p_gum__TensorT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__ThreadNumberManager[] = {  {&_swigt__p_gum__ThreadNumberManager, 0, 0, 0},  {&_swigt__p_gum__LazyPropagationT_double_t, _p_gum__LazyPropagationT_double_tTo_p_gum__ThreadNumberManager, 0, 0},  {&_swigt__p_gum__ScheduledInference, _p_gum__ScheduledInferenceTo_p_gum__ThreadNumberManager, 0, 0},  {&_swigt__p_gum__ShaferShenoyInferenceT_double_t, _p_gum__ShaferShenoyInferenceT_double_tTo_p_gum__ThreadNumberManager, 0, 0},  {&_swigt__p_gum__ShaferShenoyMRFInferenceT_double_t, _p_gum__ShaferShenoyMRFInferenceT_double_tTo_p_gum__ThreadNumberManager, 0, 0},  {&_swigt__p_gum__VariableEliminationT_double_t, _p_gum__VariableEliminationT_double_tTo_p_gum__ThreadNumberManager, 0, 0},  {&_swigt__p_gum__learning__BNLearnerT_double_t, _p_gum__learning__BNLearnerT_double_tTo_p_gum__ThreadNumberManager, 0, 0},  {&_swigt__p_gum__learning__IBNLearner, _p_gum__learning__IBNLearnerTo_p_gum__ThreadNumberManager, 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__UGmodel[] = {  {&_swigt__p_gum__UGmodel, 0, 0, 0},  {&_swigt__p_gum__IMarkovRandomFieldT_double_t, _p_gum__IMarkovRandomFieldT_double_tTo_p_gum__UGmodel, 0, 0},  {&_swigt__p_gum__MarkovRandomFieldT_double_t, _p_gum__MarkovRandomFieldT_double_tTo_p_gum__UGmodel, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__UnavailableScheduleOperation[] = {  {&_swigt__p_gum__UnavailableScheduleOperation, 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__CliqueGraph, _p_gum__CliqueGraphTo_p_gum__UndiGraph, 0, 0},  {&_swigt__p_gum__MixedGraph, _p_gum__MixedGraphTo_p_gum__UndiGraph, 0, 0},  {&_swigt__p_gum__PDAG, _p_gum__PDAGTo_p_gum__UndiGraph, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__UnexecutedScheduleOperation[] = {  {&_swigt__p_gum__UnexecutedScheduleOperation, 0, 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__UnknownScheduleMultiDim[] = {  {&_swigt__p_gum__UnknownScheduleMultiDim, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__UnknownScheduleOperation[] = {  {&_swigt__p_gum__UnknownScheduleOperation, 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__DiscretizedVariableT_double_t, _p_gum__DiscretizedVariableT_double_tTo_p_gum__Variable, 0, 0},  {&_swigt__p_gum__IDiscretizedVariable, _p_gum__IDiscretizedVariableTo_p_gum__Variable, 0, 0},  {&_swigt__p_gum__IntegerVariable, _p_gum__IntegerVariableTo_p_gum__Variable, 0, 0},  {&_swigt__p_gum__LabelizedVariable, _p_gum__LabelizedVariableTo_p_gum__Variable, 0, 0},  {&_swigt__p_gum__NumericalDiscreteVariable, _p_gum__NumericalDiscreteVariableTo_p_gum__Variable, 0, 0},  {&_swigt__p_gum__RangeVariable, _p_gum__RangeVariableTo_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},  {&_swigt__p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, _p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_tTo_p_gum__WeightedSamplingT_double_t, 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__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_t[] = {  {&_swigt__p_gum__credal__CNMonteCarloSamplingT_double_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__DatabaseTable[] = {  {&_swigt__p_gum__learning__DatabaseTable, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__learning__IBNLearner[] = {  {&_swigt__p_gum__learning__IBNLearner, 0, 0, 0},  {&_swigt__p_gum__learning__BNLearnerT_double_t, _p_gum__learning__BNLearnerT_double_tTo_p_gum__learning__IBNLearner, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iterator[] = {  {&_swigt__p_iterator, 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_iterator_safe[] = {  {&_swigt__p_iterator_safe, 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_second_type[] = {  {&_swigt__p_second_type, 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_int_t[] = {  {&_swigt__p_std__allocatorT_int_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__exception[] = {  {&_swigt__p_std__exception, 0, 0, 0},  {&_swigt__p_gum__AbstractScheduleMultiDim, _p_gum__AbstractScheduleMultiDimTo_p_std__exception, 0, 0},  {&_swigt__p_gum__ArgumentError, _p_gum__ArgumentErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__CPTError, _p_gum__CPTErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__DatabaseError, _p_gum__DatabaseErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__DefaultInLabel, _p_gum__DefaultInLabelTo_p_std__exception, 0, 0},  {&_swigt__p_gum__DuplicateElement, _p_gum__DuplicateElementTo_p_std__exception, 0, 0},  {&_swigt__p_gum__DuplicateLabel, _p_gum__DuplicateLabelTo_p_std__exception, 0, 0},  {&_swigt__p_gum__DuplicateScheduleMultiDim, _p_gum__DuplicateScheduleMultiDimTo_p_std__exception, 0, 0},  {&_swigt__p_gum__Exception, _p_gum__ExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_gum__FactoryError, _p_gum__FactoryErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__FactoryInvalidState, _p_gum__FactoryInvalidStateTo_p_std__exception, 0, 0},  {&_swigt__p_gum__FatalError, _p_gum__FatalErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__FormatNotFound, _p_gum__FormatNotFoundTo_p_std__exception, 0, 0},  {&_swigt__p_gum__GraphError, _p_gum__GraphErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__IOError, _p_gum__IOErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__IncompatibleEvidence, _p_gum__IncompatibleEvidenceTo_p_std__exception, 0, 0},  {&_swigt__p_gum__IncompatibleScorePrior, _p_gum__IncompatibleScorePriorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__InvalidArc, _p_gum__InvalidArcTo_p_std__exception, 0, 0},  {&_swigt__p_gum__InvalidArgument, _p_gum__InvalidArgumentTo_p_std__exception, 0, 0},  {&_swigt__p_gum__InvalidArgumentsNumber, _p_gum__InvalidArgumentsNumberTo_p_std__exception, 0, 0},  {&_swigt__p_gum__InvalidDirectedCycle, _p_gum__InvalidDirectedCycleTo_p_std__exception, 0, 0},  {&_swigt__p_gum__InvalidEdge, _p_gum__InvalidEdgeTo_p_std__exception, 0, 0},  {&_swigt__p_gum__InvalidNode, _p_gum__InvalidNodeTo_p_std__exception, 0, 0},  {&_swigt__p_gum__InvalidPartiallyDirectedCycle, _p_gum__InvalidPartiallyDirectedCycleTo_p_std__exception, 0, 0},  {&_swigt__p_gum__IteratorError, _p_gum__IteratorErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__LearningError, _p_gum__LearningErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__MissingValueInDatabase, _p_gum__MissingValueInDatabaseTo_p_std__exception, 0, 0},  {&_swigt__p_gum__MissingVariableInDatabase, _p_gum__MissingVariableInDatabaseTo_p_std__exception, 0, 0},  {&_swigt__p_gum__NoChild, _p_gum__NoChildTo_p_std__exception, 0, 0},  {&_swigt__p_gum__NoNeighbour, _p_gum__NoNeighbourTo_p_std__exception, 0, 0},  {&_swigt__p_gum__NoParent, _p_gum__NoParentTo_p_std__exception, 0, 0},  {&_swigt__p_gum__NotFound, _p_gum__NotFoundTo_p_std__exception, 0, 0},  {&_swigt__p_gum__NotImplementedYet, _p_gum__NotImplementedYetTo_p_std__exception, 0, 0},  {&_swigt__p_gum__NullElement, _p_gum__NullElementTo_p_std__exception, 0, 0},  {&_swigt__p_gum__OperationNotAllowed, _p_gum__OperationNotAllowedTo_p_std__exception, 0, 0},  {&_swigt__p_gum__OutOfBounds, _p_gum__OutOfBoundsTo_p_std__exception, 0, 0},  {&_swigt__p_gum__PRMTypeError, _p_gum__PRMTypeErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__PossiblyIncompatibleScorePrior, _p_gum__PossiblyIncompatibleScorePriorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__ScheduleMultiDimError, _p_gum__ScheduleMultiDimErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__ScheduleOperationError, _p_gum__ScheduleOperationErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__SizeError, _p_gum__SizeErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__SyntaxError, _p_gum__SyntaxErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__TypeError, _p_gum__TypeErrorTo_p_std__exception, 0, 0},  {&_swigt__p_gum__UnavailableScheduleOperation, _p_gum__UnavailableScheduleOperationTo_p_std__exception, 0, 0},  {&_swigt__p_gum__UndefinedElement, _p_gum__UndefinedElementTo_p_std__exception, 0, 0},  {&_swigt__p_gum__UndefinedIteratorKey, _p_gum__UndefinedIteratorKeyTo_p_std__exception, 0, 0},  {&_swigt__p_gum__UndefinedIteratorValue, _p_gum__UndefinedIteratorValueTo_p_std__exception, 0, 0},  {&_swigt__p_gum__UnexecutedScheduleOperation, _p_gum__UnexecutedScheduleOperationTo_p_std__exception, 0, 0},  {&_swigt__p_gum__UnknownLabelInDatabase, _p_gum__UnknownLabelInDatabaseTo_p_std__exception, 0, 0},  {&_swigt__p_gum__UnknownScheduleMultiDim, _p_gum__UnknownScheduleMultiDimTo_p_std__exception, 0, 0},  {&_swigt__p_gum__UnknownScheduleOperation, _p_gum__UnknownScheduleOperationTo_p_std__exception, 0, 0},  {&_swigt__p_gum__WrongClassElement, _p_gum__WrongClassElementTo_p_std__exception, 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__functionT_double_fgum__Instantiation_const_RF_t[] = {  {&_swigt__p_std__functionT_double_fgum__Instantiation_const_RF_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__mt19937[] = {  {&_swigt__p_std__mt19937, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_gum__Instantiation_double_t[] = {  {&_swigt__p_std__pairT_gum__Instantiation_double_t, 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_t[] = {  {&_swigt__p_std__vectorT_double_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_gum__SetT_std__size_t_t_std__allocatorT_gum__SetT_std__size_t_t_t_t[] = {  {&_swigt__p_std__vectorT_gum__SetT_std__size_t_t_std__allocatorT_gum__SetT_std__size_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_int_t[] = {  {&_swigt__p_std__vectorT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__size_t_std__size_t_t_std__allocatorT_std__pairT_std__size_t_std__size_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__size_t_std__size_t_t_std__allocatorT_std__pairT_std__size_t_std__size_t_t_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_t[] = {  {&_swigt__p_std__vectorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_std__string_t_std__allocatorT_std__vectorT_std__string_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_std__string_t_std__allocatorT_std__vectorT_std__string_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_unsigned_int_t[] = {  {&_swigt__p_std__vectorT_unsigned_int_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_Handler,
  _swigc__p_HandlerSafe,
  _swigc__p_IDGenerator,
  _swigc__p_InformationTheory,
  _swigc__p_IsMissing,
  _swigc__p_JunctionTreeGenerator,
  _swigc__p_MissingValType,
  _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_first_type,
  _swigc__p_gum__AbstractScheduleMultiDim,
  _swigc__p_gum__ApproximationScheme,
  _swigc__p_gum__Arc,
  _swigc__p_gum__ArcGraphPart,
  _swigc__p_gum__ArgumentError,
  _swigc__p_gum__BNdistanceT_double_t,
  _swigc__p_gum__BayesNetFragmentT_double_t,
  _swigc__p_gum__BayesNetT_double_t,
  _swigc__p_gum__CPTError,
  _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__DiGraphListener,
  _swigc__p_gum__DiscreteVariable,
  _swigc__p_gum__DiscretizedVariableT_double_t,
  _swigc__p_gum__DuplicateElement,
  _swigc__p_gum__DuplicateLabel,
  _swigc__p_gum__DuplicateScheduleMultiDim,
  _swigc__p_gum__Edge,
  _swigc__p_gum__EdgeGraphPart,
  _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__GraphicalModel,
  _swigc__p_gum__IApproximationSchemeConfiguration,
  _swigc__p_gum__IBayesNetT_double_t,
  _swigc__p_gum__IDiscretizedVariable,
  _swigc__p_gum__IMarkovRandomFieldT_double_t,
  _swigc__p_gum__IOError,
  _swigc__p_gum__ImportanceSamplingT_double_t,
  _swigc__p_gum__IncompatibleEvidence,
  _swigc__p_gum__IncompatibleScorePrior,
  _swigc__p_gum__InfluenceDiagramT_double_t,
  _swigc__p_gum__Instantiation,
  _swigc__p_gum__IntegerVariable,
  _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__InvalidPartiallyDirectedCycle,
  _swigc__p_gum__IteratorError,
  _swigc__p_gum__LabelizedVariable,
  _swigc__p_gum__LazyPropagationT_double_t,
  _swigc__p_gum__LearningError,
  _swigc__p_gum__ListConstIteratorSafeT_Debug_t,
  _swigc__p_gum__ListConstIteratorT_Debug_t,
  _swigc__p_gum__Listener,
  _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__MarkovRandomFieldT_double_t,
  _swigc__p_gum__MeekRules,
  _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_std__size_t_t,
  _swigc__p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_t_t_t,
  _swigc__p_gum__NotFound,
  _swigc__p_gum__NotImplementedYet,
  _swigc__p_gum__NullElement,
  _swigc__p_gum__NumericalDiscreteVariable,
  _swigc__p_gum__OperationNotAllowed,
  _swigc__p_gum__OutOfBounds,
  _swigc__p_gum__PDAG,
  _swigc__p_gum__PRMTypeError,
  _swigc__p_gum__PossiblyIncompatibleScorePrior,
  _swigc__p_gum__RangeVariable,
  _swigc__p_gum__ScheduleMultiDimError,
  _swigc__p_gum__ScheduleOperationError,
  _swigc__p_gum__ScheduledInference,
  _swigc__p_gum__SequenceT_gum__DiscreteVariable_const_p_t,
  _swigc__p_gum__SequenceT_std__size_t_t,
  _swigc__p_gum__SetIteratorSafeT_int_t,
  _swigc__p_gum__SetIteratorT_int_t,
  _swigc__p_gum__SetT_gum__Arc_t,
  _swigc__p_gum__SetT_gum__Arc_t__const_iterator,
  _swigc__p_gum__SetT_gum__DiscreteVariable_const_p_t,
  _swigc__p_gum__SetT_gum__Edge_t,
  _swigc__p_gum__SetT_gum__Edge_t__const_iterator,
  _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__ShaferShenoyLIMIDInferenceT_double_t,
  _swigc__p_gum__ShaferShenoyMRFInferenceT_double_t,
  _swigc__p_gum__SizeError,
  _swigc__p_gum__StructuralComparator,
  _swigc__p_gum__SyntaxError,
  _swigc__p_gum__TensorT_double_t,
  _swigc__p_gum__ThreadNumberManager,
  _swigc__p_gum__Triangulation,
  _swigc__p_gum__TypeError,
  _swigc__p_gum__UGmodel,
  _swigc__p_gum__UnavailableScheduleOperation,
  _swigc__p_gum__UndefinedElement,
  _swigc__p_gum__UndefinedIteratorKey,
  _swigc__p_gum__UndefinedIteratorValue,
  _swigc__p_gum__UndiGraph,
  _swigc__p_gum__UnexecutedScheduleOperation,
  _swigc__p_gum__UnknownLabelInDatabase,
  _swigc__p_gum__UnknownScheduleMultiDim,
  _swigc__p_gum__UnknownScheduleOperation,
  _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__credal__CNLoopyPropagationT_double_t,
  _swigc__p_gum__credal__CNMonteCarloSamplingT_double_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__DatabaseTable,
  _swigc__p_gum__learning__IBNLearner,
  _swigc__p_iterator,
  _swigc__p_iterator_category,
  _swigc__p_iterator_safe,
  _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_second_type,
  _swigc__p_size_type,
  _swigc__p_std__allocatorT_double_t,
  _swigc__p_std__allocatorT_int_t,
  _swigc__p_std__allocatorT_std__string_t,
  _swigc__p_std__allocatorT_unsigned_int_t,
  _swigc__p_std__exception,
  _swigc__p_std__functionT_double_fdoubleF_t,
  _swigc__p_std__functionT_double_fdouble_doubleF_t,
  _swigc__p_std__functionT_double_fgum__Instantiation_const_RF_t,
  _swigc__p_std__invalid_argument,
  _swigc__p_std__mt19937,
  _swigc__p_std__pairT_gum__Instantiation_double_t,
  _swigc__p_std__size_t,
  _swigc__p_std__string,
  _swigc__p_std__vectorT_PythonLoadListener_std__allocatorT_PythonLoadListener_t_t,
  _swigc__p_std__vectorT_double_t,
  _swigc__p_std__vectorT_gum__DiscreteVariable_const_p_std__allocatorT_gum__DiscreteVariable_const_p_t_t,
  _swigc__p_std__vectorT_gum__SetT_std__size_t_t_std__allocatorT_gum__SetT_std__size_t_t_t_t,
  _swigc__p_std__vectorT_int_t,
  _swigc__p_std__vectorT_std__pairT_std__size_t_std__size_t_t_std__allocatorT_std__pairT_std__size_t_std__size_t_t_t_t,
  _swigc__p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t,
  _swigc__p_std__vectorT_std__string_t,
  _swigc__p_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_std__string_t_std__allocatorT_std__vectorT_std__string_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_t_std__allocatorT_std__vectorT_double_t_t_t_t_t,
  _swigc__p_std__vectorT_unsigned_int_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

#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif

SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE 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
  
  /* -----------------------------------------------------------------------------
   * 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);
        SWIG_Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------
   * Patch %callback methods' docstrings to hold the callback ptrs
   * -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods, const 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;
        const 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;
            }
          }
        }
      }
    }
  } 
  
#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);
  SWIG_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);
  
  
  // thread safe initialization
  swig::container_owner_attribute();
  
  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);
  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_INTEGER",SWIG_From_int(static_cast< int >(gum::VarType::INTEGER)));
  SWIG_Python_SetConstant(d, "VarType_NUMERICAL",SWIG_From_int(static_cast< int >(gum::VarType::NUMERICAL)));
  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)));
  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, "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)));
  SWIG_addvarlink(globals, "_static_Set_end_", Swig_var__static_Set_end__get, Swig_var__static_Set_end__set);
  SWIG_addvarlink(globals, "_static_Set_end_safe_", Swig_var__static_Set_end_safe__get, Swig_var__static_Set_end_safe__set);
  SWIG_addvarlink(globals, "_Set_end_", Swig_var__Set_end__get, Swig_var__Set_end__set);
  SWIG_addvarlink(globals, "_Set_end_safe_", Swig_var__Set_end_safe__get, Swig_var__Set_end_safe__set);
  SWIG_addvarlink(globals, "emptyNodeSet", Swig_var_emptyNodeSet_get, Swig_var_emptyNodeSet_set);
  SWIG_addvarlink(globals, "_static_list_end_safe_", Swig_var__static_list_end_safe__get, Swig_var__static_list_end_safe__set);
  SWIG_addvarlink(globals, "_static_list_end_", Swig_var__static_list_end__get, Swig_var__static_list_end__set);
  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);
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

