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


#define SWIG_VERSION 0x040500
#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) || defined (__clang__)
#   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_NOEXCEPT noexcept
#else
# define SWIG_NOEXCEPT throw()
#endif 

#define SWIG_QUOTE_STRING(x) #x
#define SWIG_STRINGIFY(x) SWIG_QUOTE_STRING(x)

/* -----------------------------------------------------------------------------
 * 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 __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 "5"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_TYPE_TABLE_NAME SWIG_STRINGIFY(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)
/* The binary string mask denotes using string without unicode */
#define SWIG_BINARYSTRMASK         (SWIG_TMPOBJMASK << 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)
#define SWIG_BINARYSTR             (SWIG_OK | SWIG_BINARYSTRMASK)
/* 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))
#define SWIG_AddBinaryStrMask(r)   (SWIG_IsOK(r) ? (r | SWIG_BINARYSTRMASK) : r)
#define SWIG_DelBinaryStrMask(r)   (SWIG_IsOK(r) ? (r & ~SWIG_BINARYSTRMASK) : r)
#define SWIG_IsBinaryStr(r)        (SWIG_IsOK(r) && (r & SWIG_BINARYSTRMASK))

/* 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 array of casts | pointer to cast hashed by value */
  unsigned int            value;		/* index of the last valid element in the array | typename hash value */
} 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;
}

/*
 * Hash function for type name strings, based on maRushPrime1Hash (http://amsoftware.narod.ru/algo2.html)
 */
SWIGRUNTIME unsigned int SWIG_Hash(const char *str, unsigned int len) {
  const unsigned char *data = (const unsigned char *)str;
  unsigned int hash = len, i = 0, k;
  int rem = (int)len;

  while (rem >= (int)sizeof(unsigned int)) {
    memcpy(&k, data, sizeof(unsigned int));
    k += i++;
    hash ^= k;
    hash *= 171717;
    data += sizeof(unsigned int);
    rem -= (int)sizeof(unsigned int);
  }

  switch (rem) {
    case 3: k = (unsigned int)(data[2]) << 16;
            k |= (unsigned int)(data[1]) << 8;
            k |= (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
    case 2: k = (unsigned int)(data[1]) << 8;
            k |= (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
    case 1: k = (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
  }
  return hash;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  static const unsigned int scan_threshold = 4;
  if (ty) {
    swig_cast_info *head = ty->cast;
    unsigned int hash_value = 0;
    int hashed = 0;

    while (head) {

      if (strcmp(head->type->name, c) == 0) {
        return head;
      }

      if (head->value) {
        swig_cast_info *iter;
        swig_cast_info *last = head + head->value;
        swig_cast_info *first = head + 1;
        int search = 1;

        if (!hashed) {
          if (head->value < scan_threshold) {
            for (iter = first; iter <= last; iter++) {
              if (strcmp(iter->type->name, c) == 0) {
                return iter;
              }
            }
            search = 0;
          } else {
            hashed = 1;
            hash_value = SWIG_Hash(c, (unsigned int)strlen(c));
          }
        }

        if (search) {
          /* Binary search over sorted <'next'|'value'> pairs */
          do {
            iter = first + ((last - first) >> 1);
            if (iter->value < hash_value) {
              first = iter + 1;
            } else if (iter->value == hash_value) {

              if (strcmp(iter->next->type->name, c) == 0) {
                return iter->next;
              }

              /* Hash collision check */
              for (last = iter + 1; last->next && last->value == hash_value; last++) {
                if (strcmp(last->next->type->name, c) == 0) {
                  return last->next;
                }
              }
              for (first = iter - 1; first != head && first->value == hash_value; first--) {
                if (strcmp(first->next->type->name, c) == 0) {
                  return first->next;
                }
              }
              break;
            } else
              last = iter - 1;
          } while (first <= last);
        }
      }
      head = head->next;
    }
  }
  return 0;
}

/*
  Check the type by type address
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *head = ty->cast;
    while (head) {
      if (head->type == from) {
        return head;
      }

      if (head->value) {
        swig_cast_info *iter;
        swig_cast_info *last = head + head->value;
        swig_cast_info *first = head + 1;

        /* Binary search over sorted array of casts */
        do {
          iter = first + ((last - first) >> 1);
          if (iter->type < from) {
            first = iter + 1;
          } else if (iter->type == from) {
            return iter;
          } else
            last = iter - 1;
        } while (first <= last);
      }
      head = head->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 *head = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (head) {
    swig_cast_info *cast;
    for (cast = head; (unsigned int)(cast - head) <= head->value; cast++) {
      if (!cast->converter) {
        swig_type_info *tc = cast->type;
        if (!tc->clientdata) {
          SWIG_TypeClientData(tc, clientdata);
        }
      }
    }
    head = head->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 - (size_t)(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


#if !defined(SWIG_NO_HEAPTYPES)
#if !defined(SWIG_HEAPTYPES)
#define SWIG_HEAPTYPES
#endif
#endif

#if defined(SWIG_HEAPTYPES)
#if PY_VERSION_HEX < 0x030c0000
#include <structmember.h>
#define Py_READONLY READONLY
#define Py_T_PYSSIZET T_PYSSIZET
#endif
#endif

#include <stddef.h> /* For offsetof */


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

#define SWIG_RUNTIME_MODULE "swig_runtime_data" SWIG_RUNTIME_VERSION

/* 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_MODULE "." SWIGPY_CAPSULE_ATTR_NAME

#if defined(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

#if (PY_VERSION_HEX >= 0x030d00a6) && (!defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030d00a6)
# define SWIG_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName
#else
SWIGINTERN PyObject *
SWIG_PyType_GetFullyQualifiedName(PyTypeObject *type) {
  PyObject *result = NULL;
  PyObject *qualname = PyObject_GetAttrString((PyObject *)type, "__qualname__");
  if (qualname) {
    PyObject *mod = PyObject_GetAttrString((PyObject *)type, "__module__");
    if (mod) {
      if (PyUnicode_Check(mod) && PyUnicode_CompareWithASCIIString(mod, "builtins") && PyUnicode_CompareWithASCIIString(mod, "__main__")) {
        result = PyUnicode_FromFormat("%U%c%U", mod, '.', qualname);
        SWIG_Py_DECREF(qualname);
      } else {
        result = qualname;
      }
      SWIG_Py_DECREF(mod);
    } else {
      result = qualname;
    }
  }

  return result;
}
#endif

/* gh-114329 added PyList_GetItemRef() to Python 3.13.0a4 */
#if (PY_VERSION_HEX >= 0x030d00a4) && (!defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030d00a4)
# define SWIG_PyList_GetItemRef PyList_GetItemRef
#else
SWIGINTERN PyObject *
SWIG_PyList_GetItemRef(PyObject *op, Py_ssize_t index) {
  PyObject *item = PyList_GetItem(op, index);
  Py_XINCREF(item);
  return item;
}
#endif

/* gh-106004 added PyDict_GetItemRef() and PyDict_GetItemStringRef() to Python 3.13.0a1
   functions are renamed here for compatibility with abi3audit */
#if (PY_VERSION_HEX >= 0x030d00a1) && (!defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030d00a1)
# define SWIG_PyDict_GetItemRef PyDict_GetItemRef
# define SWIG_PyDict_GetItemStringRef PyDict_GetItemStringRef
#else
SWIGINTERN int
SWIG_PyDict_GetItemRef(PyObject *mp, PyObject *key, PyObject **result) {
  PyObject *item = PyDict_GetItemWithError(mp, key);
  if (item != NULL) {
    *result = (PyObject *)(item);
    SWIG_Py_INCREF(*result);
    return 1;
  }
  if (!PyErr_Occurred()) {
    *result = NULL;
    return 0;
  }
  *result = NULL;
  return -1;
}

SWIGINTERN int
SWIG_PyDict_GetItemStringRef(PyObject *mp, const char *key, PyObject **result) {
  int res;
  PyObject *key_obj = PyUnicode_FromString(key);
  if (key_obj == NULL) {
    *result = NULL;
    return -1;
  }
  res = SWIG_PyDict_GetItemRef(mp, key_obj, result);
  Py_DECREF(key_obj);
  return res;
}
#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);
    newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
    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 < 0x03050000
# error "This version of SWIG only supports Python >= 3.5"
#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 = PyUnicode_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

/* SWIG runtime data Python module */
static PyObject *Swig_runtime_data_module_global = NULL;

/* Create/obtain the single swig_runtime_data module which is used across different SWIG generated modules */
SWIGINTERN PyObject *
SWIG_runtime_data_module(void) {
  if (!Swig_runtime_data_module_global) {
#if (PY_VERSION_HEX >= 0x030d0000) && (!defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030d0000)
    /* free-threading note: the GIL is always enabled when this function is first called
       by SWIG_init, so there's no risk of race conditions */
    Swig_runtime_data_module_global = PyImport_AddModuleRef(SWIG_RUNTIME_MODULE);
#else
    Swig_runtime_data_module_global = PyImport_AddModule(SWIG_RUNTIME_MODULE);
    SWIG_Py_XINCREF(Swig_runtime_data_module_global);
#endif
  }
  assert(Swig_runtime_data_module_global);
  return Swig_runtime_data_module_global;
}

/* 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 *
SwigVarLink_repr(PyObject *SWIGUNUSEDPARM(v)) {
  return PyUnicode_InternFromString("<Swig global variables>");
}

SWIGINTERN PyObject *
SwigVarLink_str(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  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;
  return str;
}

SWIGINTERN void
SwigVarLink_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 *
SwigVarLink_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
SwigVarLink_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;
}

SWIGINTERN PyTypeObject*
SwigVarLink_TypeOnce(void) {
  static char SwigVarLink_doc[] = "Swig variable link object";
#ifndef SWIG_HEAPTYPES
  static PyTypeObject varlink_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
      PyVarObject_HEAD_INIT(NULL, 0)
      SWIG_RUNTIME_MODULE ".SwigVarLink", /* tp_name */
      sizeof(swig_varlinkobject),         /* tp_basicsize */
      0,                                  /* tp_itemsize */
      (destructor) SwigVarLink_dealloc,   /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                       /* tp_print */
#else
      (Py_ssize_t)0,                      /* tp_vectorcall_offset */
#endif
      (getattrfunc) SwigVarLink_getattr,  /* tp_getattr */
      (setattrfunc) SwigVarLink_setattr,  /* tp_setattr */
      0,                                  /* tp_compare */
      (reprfunc) SwigVarLink_repr,        /* tp_repr */
      0,                                  /* tp_as_number */
      0,                                  /* tp_as_sequence */
      0,                                  /* tp_as_mapping */
      0,                                  /* tp_hash */
      0,                                  /* tp_call */
      (reprfunc) SwigVarLink_str,         /* tp_str */
      0,                                  /* tp_getattro */
      0,                                  /* tp_setattro */
      0,                                  /* tp_as_buffer */
      0,                                  /* tp_flags */
      SwigVarLink_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 */
      0,                                  /* tp_finalize */
#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
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    varlink_type = tmp;
    type_init = 1;
    if (PyType_Ready(&varlink_type) < 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigVarLink", (PyObject *)&varlink_type) == 0)
      SWIG_Py_INCREF((PyObject *)&varlink_type);
  }
  return &varlink_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigVarLink_dealloc },
    { Py_tp_repr, (void *)SwigVarLink_repr },
    { Py_tp_getattr, (void *)SwigVarLink_getattr },
    { Py_tp_setattr, (void *)SwigVarLink_setattr },
    { Py_tp_str, (void *)SwigVarLink_str },
    { Py_tp_doc, (void *)SwigVarLink_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigVarLink",
    sizeof(swig_varlinkobject),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigVarLink", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

SWIGRUNTIME PyTypeObject*
SwigVarLink_Type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigVarLink_TypeOnce();
  return type;
}

/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
  swig_varlinkobject *result = PyObject_New(swig_varlinkobject, SwigVarLink_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 (PyObject_IsInstance(obj, (PyObject *)&PyType_Type)) {
      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;
  PyObject *swigdict;
  PyObject *weakreflist;
} SwigPyObject;


#ifdef SWIGPYTHON_BUILTIN

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

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

  SWIG_Py_XINCREF(sobj->swigdict);
  return sobj->swigdict;
}

#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 = PyUnicode_FromString(fmt);
      if (ofmt) {
        res = PyUnicode_Format(ofmt,args);
        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 = PyUnicode_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) {
      PyObject *joined = PyUnicode_Concat(repr, nrep);
      SWIG_Py_DECREF(repr);
      SWIG_Py_DECREF(nrep);
      repr = joined;
    } 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 SwigPyObject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  return SwigPyObject_repr((SwigPyObject*)v);
}

SWIGRUNTIME int
SwigPyObject_compare(PyObject *v, PyObject *w)
{
  /* tp_compare is only called when both objects have the same type, so
   * the casts are guaranteed to be ok. */
  void *i = ((SwigPyObject *)v)->ptr;
  void *j = ((SwigPyObject *)w)->ptr;
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
}

SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *);

/* Rich comparison support */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(PyObject *v, PyObject *w, int op)
{
  PyObject* res = NULL;
  if (!PyErr_Occurred()) {
    /* Per https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_richcompare
     * the first argument is guaranteed to be an instance of SwigPyObject, but the
     * second is not, so we typecheck that one. */
    if ((op != Py_EQ && op != Py_NE) || !SwigPyObject_Check(w)) {
      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
  /* Only builtin types have SwigPyObject as a base type */
  return PyType_IsSubtype(op_type, target_tp);
#else
  /* Check for an exact match to SwigPyObject */
  if (op_type == target_tp) {
    return 1;
  } else {
    /* Fallback for multiple modules */
    int cmp;
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(op_type);
    if (!tpname)
      return 0;
    cmp = PyUnicode_CompareWithASCIIString(tpname, SWIG_RUNTIME_MODULE ".SwigPyObject");
    SWIG_Py_DECREF(tpname);
    return cmp == 0;
  }
#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);
  SWIG_Py_XDECREF(sobj->swigdict);
  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
SwigPyObject_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 SwigPyObject_doc[] = "Swig object holding a C/C++ pointer";
#ifndef SWIG_HEAPTYPES
  static PyNumberMethods SwigPyObject_as_number = {
    (binaryfunc)0, /*nb_add*/
    (binaryfunc)0, /*nb_subtract*/
    (binaryfunc)0, /*nb_multiply*/
    (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_bool*/
    0,		   /*nb_invert*/
    0,		   /*nb_lshift*/
    0,		   /*nb_rshift*/
    0,		   /*nb_and*/
    0,		   /*nb_xor*/
    0,		   /*nb_or*/
    (unaryfunc)SwigPyObject_long, /*nb_int*/
    0, /*nb_reserved*/
    (unaryfunc)0,                 /*nb_float*/
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
      PyVarObject_HEAD_INIT(NULL, 0)
      SWIG_RUNTIME_MODULE ".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 */
      0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
      (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 */
      SwigPyObject_doc,                     /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      offsetof(SwigPyObject, weakreflist),  /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      SwigPyObject_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 */
      0,                                    /* tp_finalize */
#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
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    swigpyobject_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpyobject_type) != 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigPyObject", (PyObject *)&swigpyobject_type) == 0)
      SWIG_Py_INCREF((PyObject *)&swigpyobject_type);
  }
  return &swigpyobject_type;
#else
  static PyMemberDef SwigPyObject_members[] = {
      { (char *)"__dictoffset__", Py_T_PYSSIZET, offsetof(SwigPyObject, swigdict), Py_READONLY, NULL },
      { (char *)"__weaklistoffset__", Py_T_PYSSIZET, offsetof(SwigPyObject, weakreflist), Py_READONLY, NULL },
      { NULL, 0, 0, 0, NULL }
  };
  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 *)SwigPyObject_doc },
    { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
    { Py_tp_methods, (void *)SwigPyObject_methods },
    { Py_nb_int, (void *)SwigPyObject_long },
    { Py_tp_members, (void *)SwigPyObject_members },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigPyObject",
    sizeof(SwigPyObject),
    0,
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
#if !defined(Py_LIMITED_API)
/* While this __dictoffset__ is only used with the builtin wrappers, SwigPyObject ought to be
   identical when created for use by proxy class wrappers in case it is shared across multiple modules. */
#if PY_VERSION_HEX < 0x03090000
    /* Workaround as __dictoffset__ and __weaklistoffset__ above are only supported from python-3.9 */
  if (pytype) {
    ((PyTypeObject *)pytype)->tp_dictoffset = offsetof(SwigPyObject, swigdict);
    ((PyTypeObject *)pytype)->tp_weaklistoffset = offsetof(SwigPyObject, weakreflist);
  }
#endif
#endif
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyObject", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#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;
    sobj->swigdict = 0;
    sobj->weakreflist = 0;
    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 PyUnicode_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
  } else {
    return PyUnicode_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 PyUnicode_FromFormat("%s%s", result, v->ty->name);
  } else {
    return PyUnicode_FromString(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) {
  PyTypeObject *target_tp = SwigPyPacked_Type();
  PyTypeObject *op_type = Py_TYPE(op);
  /* Check for an exact match to SwigPyPacked */
  if (op_type == target_tp) {
    return 1;
  } else {
    /* Fallback for multiple modules */
    int cmp;
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(op_type);
    if (!tpname)
      return 0;
    cmp = PyUnicode_CompareWithASCIIString(tpname, SWIG_RUNTIME_MODULE ".SwigPyPacked");
    SWIG_Py_DECREF(tpname);
    return cmp == 0;
  }
}

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 SwigPyPacked_doc[] = "Swig object holding a C/C++ function pointer";
#ifndef SWIG_HEAPTYPES
  static PyTypeObject swigpypacked_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
      PyVarObject_HEAD_INIT(NULL, 0)
      SWIG_RUNTIME_MODULE ".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 */
      0, /* tp_reserved in 3.0.1 */
      (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 */
      SwigPyPacked_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 */
      0,                                    /* tp_finalize */
#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
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    swigpypacked_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpypacked_type) != 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigPyPacked", (PyObject *)&swigpypacked_type) == 0)
      SWIG_Py_INCREF((PyObject *)&swigpypacked_type);
  }
  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 *)SwigPyPacked_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigPyPacked",
    sizeof(SwigPyPacked),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyPacked", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#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 = PyUnicode_FromString("this");
  return Swig_This_global;
}

/* Returns a borrowed reference to the 'this' object */
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  PyObject *obj;

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

#ifdef SWIGPYTHON_BUILTIN
  (void)obj;
  if (PyWeakref_CheckProxy(pyobj)) {
#if PY_VERSION_HEX >= 0x030d0000
    if (PyWeakref_GetRef(pyobj, &pyobj) > 0)
      Py_DECREF(pyobj);
    else
      pyobj = NULL;
#else
    pyobj = PyWeakref_GetObject(pyobj);
#endif
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
  return NULL;
#else

  obj = 0;

  obj = PyObject_GetAttr(pyobj, SWIG_This());
  if (obj) {
    SWIG_Py_DECREF(obj);
  } else {
    if (PyErr_Occurred()) PyErr_Clear();
    return 0;
  }
  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 (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
        SWIG_Py_DECREF(inst);
        inst = 0;
      }
    }
  } else {
    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);
    }
  }
  return inst;
}

SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
  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;
        newobj->swigdict = 0;
        newobj->weakreflist = 0;
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
      if (newobj) {
        newobj->swigdict = 0;
        newobj->weakreflist = 0;
      }
    }
    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;
}


#if defined(SWIG_REFCNT_DEBUG)
#define SWIG_PYOBJ_REFCNT(OBJ) fprintf(stdout, "" #OBJ " count %ld\n", (OBJ ? Py_REFCNT(OBJ) : 0))
#else
#define SWIG_PYOBJ_REFCNT(OBJ)
#endif

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_PYOBJ_REFCNT(Swig_This_global);
  SWIG_Py_XDECREF(Swig_This_global);
  Swig_This_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_Globals_global);
  SWIG_Py_XDECREF(Swig_Globals_global);
  Swig_Globals_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_TypeCache_global);
  SWIG_Py_XDECREF(Swig_TypeCache_global);
  Swig_TypeCache_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_Capsule_global);
  Swig_Capsule_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_runtime_data_module_global);
  SWIG_Py_XDECREF(Swig_runtime_data_module_global);
  Swig_runtime_data_module_global = NULL;
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && runtime_data_module) {
    if (PyModule_AddObject(runtime_data_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)
{
  swig_type_info *descriptor;
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *obj;
  SWIG_PyDict_GetItemStringRef(cache, type, &obj);
  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_SetItemString(cache, type, obj);
    }
  }
  SWIG_Py_XDECREF(obj);
  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 : "";
}

/* 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 = Py_TYPE(obj);
  PyObject *descr;
  PyObject *encoded_name;
  descrsetfunc f;
  int res = -1;

# ifdef Py_USING_UNICODE
  if (PyBytes_Check(name)) {
    name = PyUnicode_Decode(PyBytes_AsString(name), PyBytes_Size(name), NULL, NULL);
    if (!name)
      return -1;
  } else if (!PyUnicode_Check(name))
# else
  if (!PyBytes_Check(name))
# endif
  {
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(Py_TYPE(name));
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%S'", tpname);
    SWIG_Py_DECREF(tpname);
    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 = Py_TYPE(descr)->tp_descr_set;
  if (!f) {
    if (PyBytes_Check(name)) {
      encoded_name = name;
      SWIG_Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
      if (!encoded_name)
        goto done;
    }
    PyErr_Format(PyExc_AttributeError, "'%s' object has no attribute '%s'", tp->tp_name, PyBytes_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() SWIG_NOEXCEPT {
    }

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

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


#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

#if __cplusplus >= 201103L
# define SWIG_OVERRIDE override
#else
# define SWIG_OVERRIDE
#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>

#define SWIGPY_SLICEOBJECT PyObject


#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 SwigPyIterator {
  private:
    SwigPtr_PyObject _seq;

  protected:
    SwigPyIterator(PyObject *seq) : _seq(seq)
    {
    }

    void raise_stop_iteration() const
    {
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    }

  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
    // This default probably ought to instead raise some sort of unsupported exception
    virtual SwigPyIterator *decr(size_t /*n*/ = 1)
    {
      raise_stop_iteration();
      return NULL;
    }

    // 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();
      if (obj)
        if (!incr())
          obj = NULL;
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
      return obj;     
    }

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

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

    SwigPyIterator& operator -= (ptrdiff_t n)
    {
      SwigPyIterator *ret = advance(-n);
      return ret ? *ret : *this;
    }
      
    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::" SWIG_STRINGIFY(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;
  } 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 (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   PyLong_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) : PyLong_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 (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 = PyLong_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 <string_view>


#include <utility>


#include "extensions/helpers.h"

/* numpy import helper: import_array1 must live in an int-returning function.
   Older SWIG inlines %init code directly into PyObject* PyInit_*(), which
   would make "return -1" a type error.  The wrapper below fixes that. */
static int _pyagrum_import_numpy(void) {
    import_array1(-1);
    return 0;
}


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


typedef PyObject PyAgrumSetOfArc;
typedef PyObject PyAgrumSetOfEdge;
typedef PyObject PyAgrumSetOfInt;
typedef PyObject PyAgrumSetOfStr;
typedef PyObject PyAgrumListOfSetOfInt;
typedef PyObject PyAgrumListOfInt;
typedef PyObject PyAgrumListOfStr;
typedef PyObject PyAgrumListOfArc;
typedef PyObject PyAgrumList;
typedef PyObject PyAgrumTupleFF;
typedef PyObject PyAgrumTupleOfInt;
typedef PyObject PyAgrumDictSF;
typedef PyObject PyAgrumDictState;
typedef PyObject PyAgrumInstDict;
typedef PyObject PyAgrumBool;
typedef PyObject PyAgrumFloat;
typedef PyObject PyAgrumArgMinMax;
typedef PyObject PyAgrumStr;
typedef PyObject PyAgrumNdArray;
typedef PyObject PyAgrumNone;
typedef PyObject PyAgrumDict;


#include "extensions/JunctionTreeGenerator.h"


#include <agrum/base.h>
#include <agrum/base/graphs/PAG.h>


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


#define SWIG_FromCharPtrAndSize(carray, size) SWIG_FromBinaryCharPtrAndSize(carray, size, 0)
SWIGINTERNINLINE PyObject *
SWIG_FromBinaryCharPtrAndSize(const char* carray, size_t size, int flags)
{
  if (carray) {
    if (size > (size_t)PY_SSIZE_T_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 defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
      return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#else
      if (SWIG_IsBinaryStr(flags))
        return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
      return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


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


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


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


/* 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)
{
  int use_binary = 0;       /* extract the value as raw bytes rather than as UTF-8 text */
  int is_binary = 0;        /* SWIG_BINARYSTR was passed: report the exact byte count */
  if (alloc != NULL) {
    is_binary = SWIG_IsBinaryStr(*alloc);
    use_binary = is_binary;
    *alloc = 0;
  }
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
  use_binary = 1;
#endif
  if (use_binary ? PyBytes_Check(obj) : PyUnicode_Check(obj))
  {
    char *cstr = NULL;
    Py_ssize_t len = 0;
    PyObject *bytes = NULL;
    int ret = SWIG_OK;
    if (alloc)
      *alloc = SWIG_OLDOBJ;
    if (use_binary) {
      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) {
          size_t alen = (size_t)(len + 1);
          char *p = (new char[alen]());
          if (p == NULL) {
            SWIG_Py_XDECREF(bytes);
            return SWIG_MemoryError;
          }
          memcpy(p, cstr, alen);
          cstr = p;
          *alloc = SWIG_NEWOBJ;
        } else {
          /* alloc must be set in order to clean up allocated memory */
          SWIG_Py_XDECREF(bytes);
          return SWIG_RuntimeError;
        }
      }
    }
    if (cptr) *cptr = cstr;
    if (psize) *psize = is_binary ? (size_t)len : (size_t)(len + 1);
    SWIG_Py_XDECREF(bytes);
    return ret;
  } else {

    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = (char *) vptr;
	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsPtr_std_string (PyObject * obj, std::string **val) 
{
  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
    if (buf) {
      if (val) *val = new std::string(buf, size - 1);
      if (alloc == SWIG_NEWOBJ) delete[] buf;
      return SWIG_NEWOBJ;
    } else {
      if (val) *val = 0;
      return SWIG_OLDOBJ;
    }
  } else {
    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;
}


SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) : PyLong_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) : PyLong_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 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;
}


  #define SWIG_From_double   PyFloat_FromDouble 


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


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

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 gum::NodeGraphPart const &gum_UndiGraph_nodes(gum::UndiGraph const *self){
    return self->nodes();
  }
SWIGINTERN std::string gum_UndiGraph_nameFromId(gum::UndiGraph const *self,gum::NodeId id){ return self->nameFromId(id); }
SWIGINTERN std::optional< gum::NodeId > gum_UndiGraph_idFromName(gum::UndiGraph const *self,std::string const &name){ return self->idFromName(name); }
SWIGINTERN void gum_UndiGraph_setName(gum::UndiGraph *self,gum::NodeId id,std::string const &name){ self->setName(id, name); }
SWIGINTERN bool gum_UndiGraph_hasName(gum::UndiGraph const *self,gum::NodeId id){ return self->hasName(id); }
SWIGINTERN PyAgrumSetOfInt *gum_UndiGraph_addNodes(gum::UndiGraph const *self,gum::Size n){
    return PyAgrumHelper::PySetFromNodeVect(const_cast<gum::UndiGraph *>(self)->addNodes(n));
  }
SWIGINTERN gum::EdgeSet gum_UndiGraph_edges(gum::UndiGraph const *self){ // add for the sub-classes (including MixedGraph)
    return self->edges();
  }
SWIGINTERN gum::NodeSet gum_UndiGraph_neighbours(gum::UndiGraph const *self,gum::NodeId id){
    return 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 gum::NodeGraphPart const &gum_DiGraph_nodes(gum::DiGraph const *self){
    return self->nodes();
  }
SWIGINTERN std::string gum_DiGraph_nameFromId(gum::DiGraph const *self,gum::NodeId id){ return self->nameFromId(id); }
SWIGINTERN std::optional< gum::NodeId > gum_DiGraph_idFromName(gum::DiGraph const *self,std::string const &name){ return self->idFromName(name); }
SWIGINTERN void gum_DiGraph_setName(gum::DiGraph *self,gum::NodeId id,std::string const &name){ self->setName(id, name); }
SWIGINTERN bool gum_DiGraph_hasName(gum::DiGraph const *self,gum::NodeId id){ return self->hasName(id); }
SWIGINTERN PyAgrumSetOfInt *gum_DiGraph_addNodes(gum::DiGraph const *self,gum::Size n){
    return PyAgrumHelper::PySetFromNodeVect(const_cast<gum::DiGraph *>(self)->addNodes(n));
  }
SWIGINTERN gum::ArcSet gum_DiGraph_arcs(gum::DiGraph const *self){ // add for the sub-classes (including MixedGraph and PDAG)
    return self->arcs();
  }
SWIGINTERN gum::NodeSet gum_DiGraph_parents(gum::DiGraph const *self,gum::NodeId id){
    return self->parents(id);
  }
SWIGINTERN gum::NodeSet gum_DiGraph_children(gum::DiGraph const *self,gum::NodeId id){
    return self->children(id);
  }
SWIGINTERN gum::NodeSet gum_DiGraph_descendants__SWIG_1(gum::DiGraph const *self,gum::NodeId id){
    return self->descendants(id);
  }
SWIGINTERN gum::NodeSet gum_DiGraph_ancestors__SWIG_1(gum::DiGraph const *self,gum::NodeId id){
    return self->ancestors(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 PyAgrumSetOfInt *gum_DAG_addNodes(gum::DAG const *self,gum::Size n){
    return PyAgrumHelper::PySetFromNodeVect(const_cast<gum::DAG *>(self)->addNodes(n));
  }
SWIGINTERN gum::ArcSet gum_DAG_arcs(gum::DAG const *self){ // add for the sub-classes (including MixedGraph and PDAG)
    return self->arcs();
  }
SWIGINTERN gum::NodeSet gum_DAG_parents(gum::DAG const *self,gum::NodeId id){
    return self->parents(id);
  }
SWIGINTERN gum::NodeSet gum_DAG_children(gum::DAG const *self,gum::NodeId id){
    return self->children(id);
  }
SWIGINTERN gum::NodeSet gum_DAG_descendants(gum::DAG const *self,gum::NodeId id){
    return self->descendants(id);
  }
SWIGINTERN gum::NodeSet gum_DAG_ancestors(gum::DAG const *self,gum::NodeId id){
    return self->ancestors(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 PyAgrumSetOfInt *gum_MixedGraph_addNodes(gum::MixedGraph const *self,gum::Size n){
    return PyAgrumHelper::PySetFromNodeVect(const_cast<gum::MixedGraph *>(self)->addNodes(n));
  }
SWIGINTERN gum::ArcSet gum_MixedGraph_arcs(gum::MixedGraph const *self){ // add for the sub-classes (including MixedGraph and PDAG)
    return self->arcs();
  }
SWIGINTERN gum::NodeSet gum_MixedGraph_parents(gum::MixedGraph const *self,gum::NodeId id){
    return self->parents(id);
  }
SWIGINTERN gum::NodeSet gum_MixedGraph_children(gum::MixedGraph const *self,gum::NodeId id){
    return self->children(id);
  }
SWIGINTERN gum::NodeSet gum_MixedGraph_descendants(gum::MixedGraph const *self,gum::NodeId id){
    return self->descendants(id);
  }
SWIGINTERN gum::NodeSet gum_MixedGraph_ancestors(gum::MixedGraph const *self,gum::NodeId id){
    return self->ancestors(id);
  }
SWIGINTERN gum::EdgeSet gum_MixedGraph_edges(gum::MixedGraph const *self){ // add for the sub-classes (including MixedGraph)
    return self->edges();
  }
SWIGINTERN gum::NodeSet gum_MixedGraph_neighbours(gum::MixedGraph const *self,gum::NodeId id){
    return self->neighbours(id);
  }
SWIGINTERN gum::NodeSet gum_MixedGraph_boundary(gum::MixedGraph const *self,gum::NodeId id){
    return self->boundary(id);
  }
SWIGINTERN std::optional< std::vector< gum::NodeId,std::allocator< gum::NodeId > > > gum_MixedGraph_mixedOrientedPath(gum::MixedGraph const *self,gum::NodeId node1,gum::NodeId node2){
    return self->mixedOrientedPath(node1,node2);
  }
SWIGINTERN std::optional< std::vector< gum::NodeId,std::allocator< gum::NodeId > > > gum_MixedGraph_mixedUnorientedPath(gum::MixedGraph const *self,gum::NodeId node1,gum::NodeId node2){
    return 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 PyAgrumSetOfInt *gum_PDAG_addNodes(gum::PDAG const *self,gum::Size n){
    return PyAgrumHelper::PySetFromNodeVect(const_cast<gum::PDAG *>(self)->addNodes(n));
  }
SWIGINTERN gum::ArcSet gum_PDAG_arcs(gum::PDAG const *self){ // add for the sub-classes (including MixedGraph and PDAG)
    return self->arcs();
  }
SWIGINTERN gum::NodeSet gum_PDAG_parents(gum::PDAG const *self,gum::NodeId id){
    return self->parents(id);
  }
SWIGINTERN gum::NodeSet gum_PDAG_children(gum::PDAG const *self,gum::NodeId id){
    return self->children(id);
  }
SWIGINTERN gum::NodeSet gum_PDAG_descendants(gum::PDAG const *self,gum::NodeId id){
    return self->descendants(id);
  }
SWIGINTERN gum::NodeSet gum_PDAG_ancestors(gum::PDAG const *self,gum::NodeId id){
    return self->ancestors(id);
  }
SWIGINTERN gum::EdgeSet gum_PDAG_edges(gum::PDAG const *self){ // add for the sub-classes (including MixedGraph)
    return self->edges();
  }
SWIGINTERN gum::NodeSet gum_PDAG_neighbours(gum::PDAG const *self,gum::NodeId id){
    return self->neighbours(id);
  }
SWIGINTERN gum::NodeSet gum_PDAG_boundary(gum::PDAG const *self,gum::NodeId id){
    return self->boundary(id);
  }
SWIGINTERN std::optional< std::vector< gum::NodeId,std::allocator< gum::NodeId > > > gum_PDAG_mixedOrientedPath(gum::PDAG const *self,gum::NodeId node1,gum::NodeId node2){
    return self->mixedOrientedPath(node1,node2);
  }
SWIGINTERN std::optional< std::vector< gum::NodeId,std::allocator< gum::NodeId > > > gum_PDAG_mixedUnorientedPath(gum::PDAG const *self,gum::NodeId node1,gum::NodeId node2){
    return 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 gum::NodeId gum_PAG_addNode(gum::PAG *self){
    return self->gum::NodeGraphPart::addNode();
  }
SWIGINTERN std::vector< gum::NodeId,std::allocator< gum::NodeId > > gum_PAG_addNodes(gum::PAG *self,gum::Size n){
    return self->gum::NodeGraphPart::addNodes(n);
  }
SWIGINTERN void gum_PAG_addNodeWithId(gum::PAG *self,gum::NodeId const id){
    self->gum::NodeGraphPart::addNodeWithId(id);
  }
SWIGINTERN bool gum_PAG_existsNode(gum::PAG const *self,gum::NodeId const id){
    return self->gum::NodeGraphPart::existsNode(id);
  }
SWIGINTERN gum::Size gum_PAG_size(gum::PAG const *self){
    return self->gum::NodeGraphPart::size();
  }
SWIGINTERN bool gum_PAG_empty(gum::PAG const *self){
    return self->gum::NodeGraphPart::empty();
  }
SWIGINTERN void gum_PAG_addEdge__SWIG_2(gum::PAG *self,gum::NodeId const n1,gum::NodeId const n2){
    self->addEdge(n1,n2);
  }
SWIGINTERN void gum_PAG_eraseEdge__SWIG_1(gum::PAG *self,gum::NodeId const n1,gum::NodeId const n2){
    self->eraseEdge(gum::Edge(n1,n2));
  }
SWIGINTERN bool gum_PAG_existsEdge(gum::PAG const *self,gum::NodeId const n1,gum::NodeId const n2){
    return self->existsEdge(n1,n2);
  }
SWIGINTERN gum::Size gum_PAG_sizeEdges(gum::PAG const *self){
    return self->sizeEdges();
  }
SWIGINTERN bool gum_PAG_emptyEdges(gum::PAG const *self){
    return self->emptyEdges();
  }
SWIGINTERN void gum_PAG_eraseNeighbours(gum::PAG *self,gum::NodeId const n){
    self->eraseNeighbours(n);
  }
SWIGINTERN void gum_PAG_addEdge__SWIG_3(gum::PAG *self,gum::NodeId x,gum::NodeId y,int markAtX,int markAtY){
    self->addEdge(x, y, (gum::EdgeMark)markAtX, (gum::EdgeMark)markAtY);
  }
SWIGINTERN int gum_PAG_markAt__SWIG_1(gum::PAG const *self,gum::NodeId src,gum::NodeId dst){
    return (int)self->markAt(src, dst);
  }
SWIGINTERN void gum_PAG_setMarkAt__SWIG_1(gum::PAG *self,gum::NodeId src,gum::NodeId dst,int m){
    self->setMarkAt(src, dst, (gum::EdgeMark)m);
  }
SWIGINTERN void gum_PAG_reorientAllWith__SWIG_1(gum::PAG *self,int m){
    self->reorientAllWith((gum::EdgeMark)m);
  }
SWIGINTERN gum::NodeSet gum_CliqueGraph_clique(gum::CliqueGraph const *self,gum::NodeId const clique){
    return self->clique(clique);
  }
SWIGINTERN gum::NodeSet gum_CliqueGraph_separator(gum::CliqueGraph const *self,gum::NodeId const cliq1,gum::NodeId const cliq2){
    return self->separator(cliq1,cliq2);
  }
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 PyAgrumInstDict *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 (!PyLong_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(PyLong_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 PyAgrumFloat *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);
      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);
      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);
      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);
      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);
      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);
      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);
      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);
      return self->minIn(s);
    }
SWIGINTERN PyAgrumArgMinMax *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 PyAgrumArgMinMax *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 PyAgrumNdArray *gum_Tensor_Sl_double_Sg___as_nparray_raw(gum::Tensor< double > *self,PyObject *self_pyobj){
      return PyAgrumHelper::tensorAsNpArrayRaw(self, self_pyobj);
    }
SWIGINTERN PyAgrumNdArray *gum_Tensor_Sl_double_Sg___toarray_raw(gum::Tensor< double > const *self){
      return PyAgrumHelper::tensorToArray(self);
    }
SWIGINTERN PyAgrumNone *gum_Tensor_Sl_double_Sg___fillWithNpArray(gum::Tensor< double > *self,PyObject *arr){
      if (PyAgrumHelper::tensorFillWithNpArray(self, arr) < 0)
        return nullptr;
      Py_RETURN_NONE;
    }
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 <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);
  }
}


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


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


  namespace swig {


















































    template <class 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 gum::NodeGraphPart const &gum_EssentialGraph_nodes(gum::EssentialGraph const *self){
    return self->nodes();
  }
SWIGINTERN gum::ArcSet gum_EssentialGraph_arcs(gum::EssentialGraph const *self){ // add for the sub-classes (including MixedGraph and PDAG)
    return self->arcs();
  }
SWIGINTERN gum::NodeSet gum_EssentialGraph_parents(gum::EssentialGraph const *self,gum::NodeId id){
    return self->parents(id);
  }
SWIGINTERN gum::NodeSet gum_EssentialGraph_children(gum::EssentialGraph const *self,gum::NodeId id){
    return self->children(id);
  }
SWIGINTERN gum::NodeSet gum_EssentialGraph_descendants__SWIG_1(gum::EssentialGraph const *self,gum::NodeId id){
    return self->descendants(id);
  }
SWIGINTERN gum::NodeSet gum_EssentialGraph_ancestors__SWIG_1(gum::EssentialGraph const *self,gum::NodeId id){
    return self->ancestors(id);
  }
SWIGINTERN gum::EdgeSet gum_EssentialGraph_edges(gum::EssentialGraph const *self){ // add for the sub-classes (including MixedGraph)
    return self->edges();
  }
SWIGINTERN gum::NodeSet gum_EssentialGraph_neighbours(gum::EssentialGraph const *self,gum::NodeId id){
    return self->neighbours(id);
  }
SWIGINTERN gum::NodeGraphPart const &gum_MarkovBlanket_nodes(gum::MarkovBlanket const *self){
    return self->nodes();
  }
SWIGINTERN gum::ArcSet gum_MarkovBlanket_arcs(gum::MarkovBlanket const *self){ // add for the sub-classes (including MixedGraph and PDAG)
    return self->arcs();
  }
SWIGINTERN gum::NodeSet gum_MarkovBlanket_parents(gum::MarkovBlanket const *self,gum::NodeId id){
    return self->parents(id);
  }
SWIGINTERN gum::NodeSet gum_MarkovBlanket_children(gum::MarkovBlanket const *self,gum::NodeId id){
    return self->children(id);
  }
SWIGINTERN gum::NodeSet gum_MarkovBlanket_descendants__SWIG_1(gum::MarkovBlanket const *self,gum::NodeId id){
    return self->descendants(id);
  }
SWIGINTERN gum::NodeSet gum_MarkovBlanket_ancestors__SWIG_1(gum::MarkovBlanket const *self,gum::NodeId id){
    return self->ancestors(id);
  }
SWIGINTERN void gum_StructuralMetrics_compare__SWIG_3(gum::StructuralMetrics *self,gum::BayesNet< double > const &ref,gum::BayesNet< double > const &test){
    self->compare< double, double >(ref, test);
  }
SWIGINTERN double gum_StructuralMetrics_sid__SWIG_1(gum::StructuralMetrics const *self,gum::BayesNet< double > const &ref,gum::BayesNet< double > const &test){
    return self->sid< double, double >(ref, test);
  }
SWIGINTERN PyAgrumListOfInt *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 PyAgrumSetOfInt *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 PyAgrumSetOfInt *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 PyAgrumSetOfInt *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 PyAgrumSetOfStr *gum_IBayesNet_Sl_double_Sg__names(gum::IBayesNet< double > const *self){
     PyObject* q=PySet_New(0);

     PyObject* pyval;
     for ( auto node : self->nodes()) {
       pyval=PyUnicode_FromString(self->variable(node).name().c_str());
       PySet_Add(q,pyval);
       Py_DecRef(pyval);
     }
     return q;
  }
SWIGINTERN gum::NodeGraphPart const &gum_IBayesNet_Sl_double_Sg__nodes(gum::IBayesNet< double > const *self){
    return self->nodes();
  }
SWIGINTERN PyAgrumSetOfArc *gum_IBayesNet_Sl_double_Sg__arcs(gum::IBayesNet< double > const *self){
     return PyAgrumHelper::PySetFromArcSet(self->arcs());
   }
SWIGINTERN PyAgrumSetOfInt *gum_IBayesNet_Sl_double_Sg__parents(gum::IBayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->parents(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *gum_IBayesNet_Sl_double_Sg__children(gum::IBayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->children(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *gum_IBayesNet_Sl_double_Sg__family(gum::IBayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->family(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *gum_IBayesNet_Sl_double_Sg__descendants(gum::IBayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->descendants(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *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 PyAgrumListOfInt *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 PyAgrumSetOfInt *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 PyAgrumSetOfInt *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 PyAgrumSetOfInt *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 PyAgrumSetOfStr *gum_BayesNet_Sl_double_Sg__names(gum::BayesNet< double > const *self){
     PyObject* q=PySet_New(0);

     PyObject* pyval;
     for ( auto node : self->nodes()) {
       pyval=PyUnicode_FromString(self->variable(node).name().c_str());
       PySet_Add(q,pyval);
       Py_DecRef(pyval);
     }
     return q;
  }
SWIGINTERN gum::NodeGraphPart const &gum_BayesNet_Sl_double_Sg__nodes(gum::BayesNet< double > const *self){
    return self->nodes();
  }
SWIGINTERN PyAgrumSetOfArc *gum_BayesNet_Sl_double_Sg__arcs(gum::BayesNet< double > const *self){
     return PyAgrumHelper::PySetFromArcSet(self->arcs());
   }
SWIGINTERN PyAgrumSetOfInt *gum_BayesNet_Sl_double_Sg__parents(gum::BayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->parents(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *gum_BayesNet_Sl_double_Sg__children(gum::BayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->children(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *gum_BayesNet_Sl_double_Sg__family(gum::BayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->family(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *gum_BayesNet_Sl_double_Sg__descendants(gum::BayesNet< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->descendants(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *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 void gum_BayesNet_Sl_double_Sg__loadGUM__SWIG_0(gum::BayesNet< double > *self,std::string name,PyObject *l=nullptr,bool binary=false){
      std::stringstream stream;
      try {
          gum::GumBNReader<double> reader(self,name,binary);

          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()));      }
          }
      } catch (gum::IOError& e) {
        throw(e);
      }
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__saveGUM__SWIG_0(gum::BayesNet< double > *self,std::string name,bool binary=false,int indent=2){
    gum::GumBNWriter<double> writer(binary,indent);
    writer.write( name, *self );
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg__saveGUMstring__SWIG_0(gum::BayesNet< double > *self,int indent=2){
    gum::GumBNWriter<double> writer(false,indent);
    self->updateMetaData();
    return writer.toString(*self);
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__loadGUMstring(gum::BayesNet< double > *self,std::string const &content){
    std::stringstream stream;
    try {
      gum::GumBNReader<double> reader(self);
      auto nbErr=reader.proceedFromString(content);
      reader.showElegantErrorsAndWarnings(stream);
      if (nbErr>0) {
        reader.showErrorCounts(stream);
             {                                       std::ostringstream err_stream;        err_stream << stream.str();                    throw(gum::FatalError(err_stream.str()));      }
      }
    } catch (gum::IOError& e) { throw(e); }
  }
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 PyAgrumListOfInt *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 PyAgrumSetOfInt *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 PyAgrumSetOfInt *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 PyAgrumSetOfInt *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 PyAgrumSetOfStr *gum_BayesNetFragment_Sl_double_Sg__names(gum::BayesNetFragment< double > const *self){
     PyObject* q=PySet_New(0);

     PyObject* pyval;
     for ( auto node : self->nodes()) {
       pyval=PyUnicode_FromString(self->variable(node).name().c_str());
       PySet_Add(q,pyval);
       Py_DecRef(pyval);
     }
     return q;
  }
SWIGINTERN gum::NodeGraphPart const &gum_BayesNetFragment_Sl_double_Sg__nodes(gum::BayesNetFragment< double > const *self){
    return self->nodes();
  }
SWIGINTERN PyAgrumSetOfArc *gum_BayesNetFragment_Sl_double_Sg__arcs(gum::BayesNetFragment< double > const *self){
     return PyAgrumHelper::PySetFromArcSet(self->arcs());
   }
SWIGINTERN PyAgrumSetOfInt *gum_BayesNetFragment_Sl_double_Sg__parents(gum::BayesNetFragment< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->parents(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *gum_BayesNetFragment_Sl_double_Sg__children(gum::BayesNetFragment< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->children(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *gum_BayesNetFragment_Sl_double_Sg__family(gum::BayesNetFragment< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->family(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *gum_BayesNetFragment_Sl_double_Sg__descendants(gum::BayesNetFragment< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->descendants(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *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 PyAgrumSetOfInt *gum_LazyPropagation_Sl_double_Sg__hardEvidenceNodes(gum::LazyPropagation< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_LazyPropagation_Sl_double_Sg__softEvidenceNodes(gum::LazyPropagation< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_LazyPropagation_Sl_double_Sg__targets(gum::LazyPropagation< double > const *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 PyAgrumListOfSetOfInt *gum_LazyPropagation_Sl_double_Sg__jointTargets(gum::LazyPropagation< double > const *self){
      return PyAgrumHelper::PyListOfSetsFromSetOfNodeSets(self->JointTargetedInference<double>::jointTargets());
    }
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 PyAgrumSetOfInt *gum_ShaferShenoyInference_Sl_double_Sg__hardEvidenceNodes(gum::ShaferShenoyInference< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_ShaferShenoyInference_Sl_double_Sg__softEvidenceNodes(gum::ShaferShenoyInference< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_ShaferShenoyInference_Sl_double_Sg__targets(gum::ShaferShenoyInference< double > const *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 PyAgrumListOfSetOfInt *gum_ShaferShenoyInference_Sl_double_Sg__jointTargets(gum::ShaferShenoyInference< double > const *self){
      return PyAgrumHelper::PyListOfSetsFromSetOfNodeSets(self->JointTargetedInference<double>::jointTargets());
    }
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 PyAgrumSetOfInt *gum_VariableElimination_Sl_double_Sg__hardEvidenceNodes(gum::VariableElimination< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_VariableElimination_Sl_double_Sg__softEvidenceNodes(gum::VariableElimination< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_VariableElimination_Sl_double_Sg__targets(gum::VariableElimination< double > const *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 PyAgrumListOfSetOfInt *gum_VariableElimination_Sl_double_Sg__jointTargets(gum::VariableElimination< double > const *self){
      return PyAgrumHelper::PyListOfSetsFromSetOfNodeSets(self->JointTargetedInference<double>::jointTargets());
    }
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 PyAgrumSetOfInt *gum_GibbsSampling_Sl_double_Sg__hardEvidenceNodes(gum::GibbsSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_GibbsSampling_Sl_double_Sg__softEvidenceNodes(gum::GibbsSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_GibbsSampling_Sl_double_Sg__targets(gum::GibbsSampling< double > const *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 PyAgrumSetOfInt *gum_ImportanceSampling_Sl_double_Sg__hardEvidenceNodes(gum::ImportanceSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_ImportanceSampling_Sl_double_Sg__softEvidenceNodes(gum::ImportanceSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_ImportanceSampling_Sl_double_Sg__targets(gum::ImportanceSampling< double > const *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 PyAgrumSetOfInt *gum_WeightedSampling_Sl_double_Sg__hardEvidenceNodes(gum::WeightedSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_WeightedSampling_Sl_double_Sg__softEvidenceNodes(gum::WeightedSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_WeightedSampling_Sl_double_Sg__targets(gum::WeightedSampling< double > const *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 PyAgrumSetOfInt *gum_MonteCarloSampling_Sl_double_Sg__hardEvidenceNodes(gum::MonteCarloSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_MonteCarloSampling_Sl_double_Sg__softEvidenceNodes(gum::MonteCarloSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_MonteCarloSampling_Sl_double_Sg__targets(gum::MonteCarloSampling< double > const *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 PyAgrumSetOfInt *gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__hardEvidenceNodes(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__softEvidenceNodes(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__targets(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *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 PyAgrumSetOfInt *gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__hardEvidenceNodes(gum::LoopySamplingInference< double,gum::WeightedSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__softEvidenceNodes(gum::LoopySamplingInference< double,gum::WeightedSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__targets(gum::LoopySamplingInference< double,gum::WeightedSampling > const *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 PyAgrumSetOfInt *gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__hardEvidenceNodes(gum::LoopySamplingInference< double,gum::GibbsSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__softEvidenceNodes(gum::LoopySamplingInference< double,gum::GibbsSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__targets(gum::LoopySamplingInference< double,gum::GibbsSampling > const *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 PyAgrumSetOfInt *gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__hardEvidenceNodes(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__softEvidenceNodes(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__targets(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *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 PyAgrumSetOfInt *gum_LoopyBeliefPropagation_Sl_double_Sg__hardEvidenceNodes(gum::LoopyBeliefPropagation< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_LoopyBeliefPropagation_Sl_double_Sg__softEvidenceNodes(gum::LoopyBeliefPropagation< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes());
    }
SWIGINTERN PyAgrumSetOfInt *gum_LoopyBeliefPropagation_Sl_double_Sg__targets(gum::LoopyBeliefPropagation< double > const *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 PyAgrumDict *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=PyLong_FromLong(self->errorPQ());
  PyDict_SetItemString(q,"errorPQ",pyval);
  Py_DecRef(pyval);

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

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

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

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

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

  return q;
}
SWIGINTERN PyAgrumDict *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=PyLong_FromLong(self->errorPQ());
  PyDict_SetItemString(q,"errorPQ",pyval);
  Py_DecRef(pyval);

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

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

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

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

  pyval=PyFloat_FromDouble(self->jsd());
  PyDict_SetItemString(q,"jensen-shannon",pyval);
  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 PyAgrumDict *gum_MCBNDistance_Sl_double_Sg__compute(gum::MCBNDistance< double > *self){
  PyObject* q=PyDict_New();

  PyObject* pyval;

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

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

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

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

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

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

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

  return q;
}
SWIGINTERN void gum_MCBNDistance_Sl_double_Sg__setVerbosity(gum::MCBNDistance< double > *self,bool v){ self->gum::ApproximationScheme::setVerbosity(v); }
SWIGINTERN void gum_MCBNDistance_Sl_double_Sg__setEpsilon(gum::MCBNDistance< double > *self,double eps){ self->gum::ApproximationScheme::setEpsilon(eps); }
SWIGINTERN void gum_MCBNDistance_Sl_double_Sg__setMinEpsilonRate(gum::MCBNDistance< double > *self,double rate){ self->gum::ApproximationScheme::setMinEpsilonRate(rate); }
SWIGINTERN void gum_MCBNDistance_Sl_double_Sg__setMaxIter(gum::MCBNDistance< double > *self,gum::Size max){ self->gum::ApproximationScheme::setMaxIter(max); }
SWIGINTERN void gum_MCBNDistance_Sl_double_Sg__setMaxTime(gum::MCBNDistance< double > *self,double timeout){ self->gum::ApproximationScheme::setMaxTime(timeout); }
SWIGINTERN void gum_MCBNDistance_Sl_double_Sg__setPeriodSize(gum::MCBNDistance< double > *self,gum::Size p){ self->gum::ApproximationScheme::setPeriodSize(p); }
SWIGINTERN bool gum_MCBNDistance_Sl_double_Sg__verbosity(gum::MCBNDistance< double > const *self){ return self->gum::ApproximationScheme::verbosity(); }
SWIGINTERN double gum_MCBNDistance_Sl_double_Sg__epsilon(gum::MCBNDistance< double > const *self){ return self->gum::ApproximationScheme::epsilon(); }
SWIGINTERN double gum_MCBNDistance_Sl_double_Sg__minEpsilonRate(gum::MCBNDistance< double > const *self){ return self->gum::ApproximationScheme::minEpsilonRate(); }
SWIGINTERN gum::Size gum_MCBNDistance_Sl_double_Sg__maxIter(gum::MCBNDistance< double > const *self){ return self->gum::ApproximationScheme::maxIter(); }
SWIGINTERN double gum_MCBNDistance_Sl_double_Sg__maxTime(gum::MCBNDistance< double > const *self){ return self->gum::ApproximationScheme::maxTime(); }
SWIGINTERN gum::Size gum_MCBNDistance_Sl_double_Sg__periodSize(gum::MCBNDistance< double > const *self){ return self->gum::ApproximationScheme::periodSize(); }
SWIGINTERN gum::Size gum_MCBNDistance_Sl_double_Sg__nbrIterations(gum::MCBNDistance< double > const *self){ return self->gum::ApproximationScheme::nbrIterations(); }
SWIGINTERN double gum_MCBNDistance_Sl_double_Sg__currentTime(gum::MCBNDistance< double > const *self){ return self->gum::ApproximationScheme::currentTime(); }
SWIGINTERN std::string gum_MCBNDistance_Sl_double_Sg__messageApproximationScheme(gum::MCBNDistance< double > const *self){ return self->gum::ApproximationScheme::messageApproximationScheme(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_MCBNDistance_Sl_double_Sg__history(gum::MCBNDistance< double > const *self){ return self->gum::ApproximationScheme::history(); }
SWIGINTERN gum::IApproximationSchemeConfiguration const &gum_MCBNDistance_Sl_double_Sg___asIApproximationSchemeConfiguration(gum::MCBNDistance< double > const *self){
    return *(dynamic_cast<const gum::IApproximationSchemeConfiguration *>(self));
  }
SWIGINTERN PyAgrumTupleOfInt *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 gum::PAG gum_learning_BNLearner_Sl_double_Sg__learnPAG(gum::learning::BNLearner< double > *self){ return self->gum::learning::IBNLearner::learnPAG(); }
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_view 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_view 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_view 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_view var1,std::string_view 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_view var1,std::string_view 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_view var1,std::string_view 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_view var1,std::string_view 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_view 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 PyAgrumTupleFF *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 PyAgrumTupleFF *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 (PyLong_Check(row) != 0) {
          ranks.insert(PyLong_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 (PyLong_Check(row) == 0) {
        PyErr_SetString(PyExc_TypeError, "arg must be a sequence of int");
        return  *self;
      }
      v.push_back((gum::NodeId)PyLong_AsLong(row));
    }

    self->useK2(v);
    return *self;
  }
SWIGINTERN PyAgrumListOfArc *gum_learning_BNLearner_Sl_double_Sg__latentVariables(gum::learning::BNLearner< double > *self){
    return PyAgrumHelper::PyListFromArcVect(self->latentVariables());
  }
SWIGINTERN PyAgrumDictState *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 PyAgrumSetOfStr *gum_InfluenceDiagram_Sl_double_Sg__names(gum::InfluenceDiagram< double > const *self){
     PyObject* q=PySet_New(0);

     PyObject* pyval;
     for ( auto node : self->nodes()) {
       pyval=PyUnicode_FromString(self->variable(node).name().c_str());
       PySet_Add(q,pyval);
       Py_DecRef(pyval);
     }
     return q;
  }
SWIGINTERN gum::NodeGraphPart const &gum_InfluenceDiagram_Sl_double_Sg__nodes(gum::InfluenceDiagram< double > const *self){
    return self->nodes();
  }
SWIGINTERN PyAgrumSetOfArc *gum_InfluenceDiagram_Sl_double_Sg__arcs(gum::InfluenceDiagram< double > const *self){
     return PyAgrumHelper::PySetFromArcSet(self->arcs());
   }
SWIGINTERN PyAgrumSetOfInt *gum_InfluenceDiagram_Sl_double_Sg__parents(gum::InfluenceDiagram< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->parents(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *gum_InfluenceDiagram_Sl_double_Sg__children(gum::InfluenceDiagram< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->children(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *gum_InfluenceDiagram_Sl_double_Sg__family(gum::InfluenceDiagram< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->family(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *gum_InfluenceDiagram_Sl_double_Sg__descendants(gum::InfluenceDiagram< double > const *self,PyObject *norid){
     return PyAgrumHelper::PySetFromNodeSet(self->descendants(PyAgrumHelper::nodeIdFromNameOrIndex(norid,self->variableNodeMap())));
   }
SWIGINTERN PyAgrumSetOfInt *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 void gum_InfluenceDiagram_Sl_double_Sg__loadGUM__SWIG_0(gum::InfluenceDiagram< double > *self,std::string name,bool binary=false){
    std::stringstream stream;
    try {
      gum::GumIDReader<double> reader(self,name,binary);
      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()));      }
      }
    } catch (gum::IOError& e) { throw(e); }
  }
SWIGINTERN void gum_InfluenceDiagram_Sl_double_Sg__saveGUM__SWIG_0(gum::InfluenceDiagram< double > *self,std::string name,bool binary=false,int indent=2){
    gum::GumIDWriter<double> writer(binary,indent);
    writer.write(name,*self);
  }
SWIGINTERN std::string gum_InfluenceDiagram_Sl_double_Sg__saveGUMstring__SWIG_0(gum::InfluenceDiagram< double > *self,int indent=2){
    gum::GumIDWriter<double> writer(false,indent);
    self->updateMetaData();
    return writer.toString(*self);
  }
SWIGINTERN void gum_InfluenceDiagram_Sl_double_Sg__loadGUMstring(gum::InfluenceDiagram< double > *self,std::string const &content){
    std::stringstream stream;
    try {
      gum::GumIDReader<double> reader(self);
      auto nbErr=reader.proceedFromString(content);
      reader.showElegantErrorsAndWarnings(stream);
      if (nbErr>0) {
        reader.showErrorCounts(stream);
             {                                       std::ostringstream err_stream;        err_stream << stream.str();                    throw(gum::FatalError(err_stream.str()));      }
      }
    } catch (gum::IOError& e) { throw(e); }
  }
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 PyAgrumSetOfInt *gum_ShaferShenoyLIMIDInference_Sl_double_Sg__hardEvidenceNodes(gum::ShaferShenoyLIMIDInference< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyAgrumSetOfInt *gum_ShaferShenoyLIMIDInference_Sl_double_Sg__softEvidenceNodes(gum::ShaferShenoyLIMIDInference< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyAgrumDictSF *gum_ShaferShenoyLIMIDInference_Sl_double_Sg__MEU__SWIG_1(gum::ShaferShenoyLIMIDInference< double > *self){
    std::cout<<"H"<<std::endl;
      return PyAgrumHelper::PyDictFromPairMeanVar(self->MEU() ) ;
    }
SWIGINTERN PyAgrumDictSF *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 PyAgrumSetOfStr *gum_IMarkovRandomField_Sl_double_Sg__names(gum::IMarkovRandomField< double > const *self){
     PyObject* q=PySet_New(0);

     PyObject* pyval;
     for ( auto node : self->nodes()) {
       pyval=PyUnicode_FromString(self->variable(node).name().c_str());
       PySet_Add(q,pyval);
       Py_DecRef(pyval);
     }
     return q;
  }
SWIGINTERN gum::NodeGraphPart const &gum_IMarkovRandomField_Sl_double_Sg__nodes(gum::IMarkovRandomField< double > const *self){
    return self->nodes();
  }
SWIGINTERN PyAgrumSetOfInt *gum_IMarkovRandomField_Sl_double_Sg__neighbours(gum::IMarkovRandomField< double > const *self,PyObject *norid){
    return PyAgrumHelper::PySetFromNodeSet(self->neighbours(
       PyAgrumHelper::nodeIdFromNameOrIndex(norid, self->variableNodeMap())));
  }
SWIGINTERN PyAgrumSetOfEdge *gum_IMarkovRandomField_Sl_double_Sg__edges(gum::IMarkovRandomField< double > const *self){
    return PyAgrumHelper::PySetFromEdgeSet(self->graph().edges());
  }
SWIGINTERN PyAgrumSetOfInt *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 PyAgrumSetOfInt *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 PyAgrumSetOfStr *gum_MarkovRandomField_Sl_double_Sg__names(gum::MarkovRandomField< double > const *self){
     PyObject* q=PySet_New(0);

     PyObject* pyval;
     for ( auto node : self->nodes()) {
       pyval=PyUnicode_FromString(self->variable(node).name().c_str());
       PySet_Add(q,pyval);
       Py_DecRef(pyval);
     }
     return q;
  }
SWIGINTERN gum::NodeGraphPart const &gum_MarkovRandomField_Sl_double_Sg__nodes(gum::MarkovRandomField< double > const *self){
    return self->nodes();
  }
SWIGINTERN PyAgrumSetOfInt *gum_MarkovRandomField_Sl_double_Sg__neighbours(gum::MarkovRandomField< double > const *self,PyObject *norid){
    return PyAgrumHelper::PySetFromNodeSet(self->neighbours(
       PyAgrumHelper::nodeIdFromNameOrIndex(norid, self->variableNodeMap())));
  }
SWIGINTERN PyAgrumSetOfEdge *gum_MarkovRandomField_Sl_double_Sg__edges(gum::MarkovRandomField< double > const *self){
    return PyAgrumHelper::PySetFromEdgeSet(self->graph().edges());
  }
SWIGINTERN PyAgrumSetOfInt *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 PyAgrumSetOfInt *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 void gum_MarkovRandomField_Sl_double_Sg__loadGUM__SWIG_0(gum::MarkovRandomField< double > *self,std::string name,bool binary=false){
    std::stringstream stream;
    try {
      gum::GumMRFReader<double> reader(self,name,binary);
      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()));      }
      }
    } catch (gum::IOError& e) { throw(e); }
  }
SWIGINTERN void gum_MarkovRandomField_Sl_double_Sg__saveGUM__SWIG_0(gum::MarkovRandomField< double > *self,std::string name,bool binary=false,int indent=2){
    gum::GumMRFWriter<double> writer(binary,indent);
    writer.write(name,*self);
  }
SWIGINTERN std::string gum_MarkovRandomField_Sl_double_Sg__saveGUMstring__SWIG_0(gum::MarkovRandomField< double > *self,int indent=2){
    gum::GumMRFWriter<double> writer(false,indent);
    self->updateMetaData();
    return writer.toString(*self);
  }
SWIGINTERN void gum_MarkovRandomField_Sl_double_Sg__loadGUMstring(gum::MarkovRandomField< double > *self,std::string const &content){
    std::stringstream stream;
    try {
      gum::GumMRFReader<double> reader(self);
      auto nbErr=reader.proceedFromString(content);
      reader.showElegantErrorsAndWarnings(stream);
      if (nbErr>0) {
        reader.showErrorCounts(stream);
             {                                       std::ostringstream err_stream;        err_stream << stream.str();                    throw(gum::FatalError(err_stream.str()));      }
      }
    } catch (gum::IOError& e) { throw(e); }
  }
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 PyAgrumSetOfInt *gum_ShaferShenoyMRFInference_Sl_double_Sg__hardEvidenceNodes(gum::ShaferShenoyMRFInference< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyAgrumSetOfInt *gum_ShaferShenoyMRFInference_Sl_double_Sg__softEvidenceNodes(gum::ShaferShenoyMRFInference< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyAgrumSetOfInt *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 PyAgrumListOfSetOfInt *gum_ShaferShenoyMRFInference_Sl_double_Sg__jointTargets(gum::ShaferShenoyMRFInference< double > const *self){
      return PyAgrumHelper::PyListOfSetsFromSetOfNodeSets(self->JointTargetedMRFInference<double>::jointTargets());
    }

#include <agrum/cm.h>




SWIGINTERN gum::CausalModel< double > *new_gum_CausalModel_Sl_double_Sg___SWIG_5(gum::BayesNet< double > const &bn,PyObject *latents,bool assumeNonSpurious=false){
    auto* cm = new gum::CausalModel<double>(bn);
    if (latents == Py_None) return cm;
    if (!PySequence_Check(latents)) {
      delete cm;
      PyErr_SetString(PyExc_TypeError, "CausalModel: latents must be a sequence of (name, children) pairs");
      return nullptr;
    }
    Py_ssize_t n = PySequence_Size(latents);
    for (Py_ssize_t i = 0; i < n; ++i) {
      PyObject* item = PySequence_GetItem(latents, i);
      if (!PySequence_Check(item) || PySequence_Size(item) != 2) {
        Py_DecRef(item);
        delete cm;
        PyErr_SetString(PyExc_TypeError, "CausalModel: each latent descriptor must be a (name, children) pair");
        return nullptr;
      }
      PyObject* pyname     = PySequence_GetItem(item, 0);
      PyObject* pychildren = PySequence_GetItem(item, 1);
      Py_DecRef(item);
      std::string              name = PyAgrumHelper::stringFromPyObject(pyname);
      Py_DecRef(pyname);
      std::vector<std::string> childNames;
      Py_ssize_t               nc = PySequence_Size(pychildren);
      for (Py_ssize_t j = 0; j < nc; ++j) {
        PyObject* child = PySequence_GetItem(pychildren, j);
        childNames.push_back(PyAgrumHelper::stringFromPyObject(child));
        Py_DecRef(child);
      }
      Py_DecRef(pychildren);
      cm->addLatentVariable(name, childNames, assumeNonSpurious);
    }
    return cm;
  }
SWIGINTERN PyAgrumDict *gum_CausalImpact_Sl_double_Sg__toDict(gum::CausalImpact< double > const *self){
    if (!self->isIdentified()) Py_RETURN_NONE;
    return PyAgrumHelper::PyDictFromASTtree(self->root());
  }


/* ---------------------------------------------------
 * 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);
  result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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);
  result = (swig::SwigPyIterator *)(arg1)->incr(SWIG_STD_MOVE(*(&arg2)));
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 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);
  result = (swig::SwigPyIterator *)(arg1)->incr();
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 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);
  result = (swig::SwigPyIterator *)(arg1)->decr(SWIG_STD_MOVE(*(&arg2)));
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 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);
  result = (swig::SwigPyIterator *)(arg1)->decr();
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 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();
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  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);
  result = (PyObject *)(arg1)->__next__();
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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);
  result = (PyObject *)(arg1)->previous();
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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);
  result = (swig::SwigPyIterator *)(arg1)->advance(SWIG_STD_MOVE(*(&arg2)));
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 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);
  result = (swig::SwigPyIterator *) &(arg1)->operator +=(SWIG_STD_MOVE(*(&arg2)));
  if (PyErr_Occurred()) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  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);
  result = (swig::SwigPyIterator *) &(arg1)->operator -=(SWIG_STD_MOVE(*(&arg2)));
  if (PyErr_Occurred()) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  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);
  result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(SWIG_STD_MOVE(*(&arg2)));
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  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);
  result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(SWIG_STD_MOVE(*(&arg2)));
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  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 ;
  PyAgrumListOfInt *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 = (PyAgrumListOfInt *)((JunctionTreeGenerator const *)arg1)->eliminationOrder((gum::UndiGraph const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumListOfInt *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 = (PyAgrumListOfInt *)((JunctionTreeGenerator const *)arg1)->eliminationOrder((gum::UndiGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumListOfInt *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 = (PyAgrumListOfInt *)((JunctionTreeGenerator const *)arg1)->eliminationOrder((gum::DAG const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumListOfInt *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 = (PyAgrumListOfInt *)((JunctionTreeGenerator const *)arg1)->eliminationOrder((gum::DAG const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumListOfInt *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 = (PyAgrumListOfInt *)((JunctionTreeGenerator const *)arg1)->eliminationOrder((gum::BayesNet< double > const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumListOfInt *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 = (PyAgrumListOfInt *)((JunctionTreeGenerator const *)arg1)->eliminationOrder((gum::BayesNet< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 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_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  gum::Exception *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GumException__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  gum::Exception *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  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_view,std::string_view)\n"
    "    gum::Exception::Exception(std::string_view)\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_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  std::string_view arg4 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *bytes4 = NULL ;
  PyObject *swig_obj[4] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_createMsg_", 4, 4, swig_obj)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[3]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[3]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[3])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[3], &len, &bytes4);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[3]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[3]);
    }
#endif
    arg4 = std::string_view(p, len);
  }
  {
    try {
      result = gum::_createMsg_(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&arg2)),arg3,SWIG_STD_MOVE(*(&arg4)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  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_HedgeException__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::HedgeException *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_HedgeException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_HedgeException" "', 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_HedgeException" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_HedgeException" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::HedgeException *)new gum::HedgeException((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__HedgeException, 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_HedgeException__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::HedgeException *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_HedgeException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_HedgeException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::HedgeException *)new gum::HedgeException((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__HedgeException, 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_HedgeException__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::HedgeException *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::HedgeException *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__HedgeException,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HedgeException" "', argument " "1"" of type '" "gum::HedgeException const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_HedgeException" "', argument " "1"" of type '" "gum::HedgeException const &""'"); 
  }
  arg1 = reinterpret_cast< gum::HedgeException * >(argp1);
  {
    try {
      result = (gum::HedgeException *)new gum::HedgeException((gum::HedgeException const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__HedgeException, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HedgeException(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HedgeException", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__HedgeException, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_HedgeException__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_HedgeException__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_HedgeException__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_HedgeException'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::HedgeException::HedgeException(std::string const &,std::string const &)\n"
    "    gum::HedgeException::HedgeException(std::string const &)\n"
    "    gum::HedgeException::HedgeException(gum::HedgeException const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HedgeException(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::HedgeException *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__HedgeException, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HedgeException" "', argument " "1"" of type '" "gum::HedgeException *""'"); 
  }
  arg1 = reinterpret_cast< gum::HedgeException * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HedgeException_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__HedgeException, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HedgeException_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;
    }
  }
  {
    std::vector< std::pair< std::size_t, std::size_t > > _v = std::move(result);
    Py_ssize_t _n = static_cast<Py_ssize_t>(_v.size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _pair = PyTuple_New(2);
      PyTuple_SET_ITEM(_pair, 0, PyLong_FromUnsignedLong(static_cast<unsigned long>(_v[_i].first)));
      PyTuple_SET_ITEM(_pair, 1, PyLong_FromUnsignedLong(static_cast<unsigned long>(_v[_i].second)));
      PyTuple_SET_ITEM(resultobj, _i, _pair);
    }
  }
  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_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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->setName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      ((gum::Variable const *)arg1)->setDescription(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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] ;
  SwigValueWrapper< 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;
    }
  }
  {
    std::vector<std::string> _v = std::move(result);
    Py_ssize_t _n = static_cast<Py_ssize_t>(_v.size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyUnicode_FromString(_v[_i].c_str()));
  }
  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_isNumerical(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_isNumerical" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = (bool)((gum::DiscreteVariable const *)arg1)->isNumerical();
    } 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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::DiscreteVariable const *)arg1)->index(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg1 ;
  std::string_view arg2 ;
  gum::Size arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::LabelizedVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LabelizedVariable, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LabelizedVariable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  gum::LabelizedVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::LabelizedVariable *)new gum::LabelizedVariable(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LabelizedVariable, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LabelizedVariable__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  gum::LabelizedVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::LabelizedVariable *)new gum::LabelizedVariable(SWIG_STD_MOVE(*(&arg1)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LabelizedVariable, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LabelizedVariable__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  std::vector< std::string > _tmp_vs3 ;
  gum::LabelizedVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    try {
      result = (gum::LabelizedVariable *)new gum::LabelizedVariable(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,std::string_view,gum::Size const)\n"
    "    gum::LabelizedVariable::LabelizedVariable(std::string_view,std::string_view)\n"
    "    gum::LabelizedVariable::LabelizedVariable(std::string_view)\n"
    "    gum::LabelizedVariable::LabelizedVariable(std::string_view,std::string_view,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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::LabelizedVariable const *)arg1)->index(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_isLabel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (bool)((gum::LabelizedVariable const *)arg1)->isLabel(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_addLabel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::LabelizedVariable *) &(arg1)->addLabel(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_changeLabel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  gum::Idx arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      ((gum::LabelizedVariable const *)arg1)->changeLabel(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::LabelizedVariable const *)arg1)->posLabel(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg1 ;
  std::string_view arg2 ;
  long arg3 ;
  long arg4 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  long val3 ;
  int ecode3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  gum::RangeVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&arg2)),arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__RangeVariable, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RangeVariable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  gum::RangeVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::RangeVariable *)new gum::RangeVariable(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__RangeVariable, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,std::string_view,long,long)\n"
    "    gum::RangeVariable::RangeVariable(std::string_view,std::string_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::RangeVariable const *)arg1)->index(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  gum::IntegerVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::IntegerVariable *)new gum::IntegerVariable(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IntegerVariable, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntegerVariable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  gum::IntegerVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::IntegerVariable *)new gum::IntegerVariable(SWIG_STD_MOVE(*(&arg1)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IntegerVariable, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntegerVariable__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  std::vector< int,std::allocator< int > > *arg3 = 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  std::vector< int > _tmp_vi3 ;
  gum::IntegerVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of ints");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vi3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) SWIG_fail;
      _tmp_vi3.push_back(static_cast<int>(_val));
    }
    arg3 = &_tmp_vi3;
  }
  {
    try {
      result = (gum::IntegerVariable *)new gum::IntegerVariable(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntegerVariable__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  int arg4 ;
  gum::Size arg5 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  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;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,std::string_view)\n"
    "    gum::IntegerVariable::IntegerVariable(std::string_view)\n"
    "    gum::IntegerVariable::IntegerVariable(std::string_view,std::string_view,std::vector< int,std::allocator< int > > const &)\n"
    "    gum::IntegerVariable::IntegerVariable(std::string_view,std::string_view,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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::IntegerVariable const *)arg1)->index(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyLong_FromLong((*result)[_i]));
  }
  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_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  gum::NumericalDiscreteVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::NumericalDiscreteVariable *)new gum::NumericalDiscreteVariable(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NumericalDiscreteVariable, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumericalDiscreteVariable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  gum::NumericalDiscreteVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::NumericalDiscreteVariable *)new gum::NumericalDiscreteVariable(SWIG_STD_MOVE(*(&arg1)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NumericalDiscreteVariable, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumericalDiscreteVariable__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  std::vector< double > _tmp_vd3 ;
  gum::NumericalDiscreteVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    try {
      result = (gum::NumericalDiscreteVariable *)new gum::NumericalDiscreteVariable(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumericalDiscreteVariable__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  double arg3 ;
  double arg4 ;
  gum::Size arg5 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  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;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,std::string_view)\n"
    "    gum::NumericalDiscreteVariable::NumericalDiscreteVariable(std::string_view)\n"
    "    gum::NumericalDiscreteVariable::NumericalDiscreteVariable(std::string_view,std::string_view,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::NumericalDiscreteVariable::NumericalDiscreteVariable(std::string_view,std::string_view,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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::NumericalDiscreteVariable const *)arg1)->index(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Edge *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< gum::Edge > rvrdeleter1 ;
  gum::Edge *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__Edge, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Edge" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "gum::Edge &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Edge" "', argument " "1"" of type '" "gum::Edge &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Edge" "', argument " "1"" of type '" "gum::Edge &&""'"); 
  }
  arg1 = reinterpret_cast< gum::Edge * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    try {
      result = (gum::Edge *)new gum::Edge((gum::Edge &&)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Edge, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Edge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Edge", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__Edge, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_Edge__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Edge__SWIG_2(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"
    "    gum::Edge::Edge(gum::Edge &&)\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__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< gum::Arc > rvrdeleter1 ;
  gum::Arc *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__Arc, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Arc" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "gum::Arc &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Arc" "', argument " "1"" of type '" "gum::Arc &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Arc" "', argument " "1"" of type '" "gum::Arc &&""'"); 
  }
  arg1 = reinterpret_cast< gum::Arc * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    try {
      result = (gum::Arc *)new gum::Arc((gum::Arc &&)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Arc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Arc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Arc", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__Arc, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_Arc__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Arc__SWIG_2(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"
    "    gum::Arc::Arc(gum::Arc &&)\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__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< gum::UndiGraph > rvrdeleter1 ;
  gum::UndiGraph *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UndiGraph" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "gum::UndiGraph &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UndiGraph" "', argument " "1"" of type '" "gum::UndiGraph &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UndiGraph" "', argument " "1"" of type '" "gum::UndiGraph &&""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    try {
      result = (gum::UndiGraph *)new gum::UndiGraph((gum::UndiGraph &&)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndiGraph(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) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_UndiGraph__SWIG_6(self, argc, argv);
  }
check_3:
  
  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"
    "    gum::UndiGraph::UndiGraph(gum::UndiGraph &&)\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_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 = 0 ;
  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_chainComponents(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_chainComponents" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = ((gum::UndiGraph const *)arg1)->chainComponents();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PyDictFromNodePropertyNodeId(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_connectedComponents(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_connectedComponents" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = ((gum::UndiGraph const *)arg1)->connectedComponents();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PyDictFromNodePropertyNodeId(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_undirectedPath(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] ;
  std::optional< std::vector< gum::NodeId,std::allocator< gum::NodeId > > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph_undirectedPath", 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_undirectedPath" "', 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_undirectedPath" "', 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_undirectedPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = ((gum::UndiGraph const *)arg1)->undirectedPath(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PyListFromNodeVect((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_hasUndirectedPath__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 ;
  bool result;
  
  (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_hasUndirectedPath" "', 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_hasUndirectedPath" "', 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_hasUndirectedPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)((gum::UndiGraph const *)arg1)->hasUndirectedPath(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_hasUndirectedPath__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UndiGraph *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 ;
  gum::NodeSet _ns_temp4 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) 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_hasUndirectedPath" "', 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_hasUndirectedPath" "', 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_hasUndirectedPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    try {
      result = (bool)((gum::UndiGraph const *)arg1)->hasUndirectedPath(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_UndiGraph_hasUndirectedPath__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  gum::NodeSet *arg3 = 0 ;
  gum::NodeSet *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  gum::NodeSet _ns_temp4 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) 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_hasUndirectedPath" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    try {
      result = (bool)((gum::UndiGraph const *)arg1)->hasUndirectedPath((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_UndiGraph_hasUndirectedPath(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UndiGraph_hasUndirectedPath", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_UndiGraph_hasUndirectedPath__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_2;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_2;
    PyObject *retobj = _wrap_UndiGraph_hasUndirectedPath__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_2:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_UndiGraph_hasUndirectedPath__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_hasUndirectedPath'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UndiGraph::hasUndirectedPath(gum::NodeId,gum::NodeId) const\n"
    "    gum::UndiGraph::hasUndirectedPath(gum::NodeId,gum::NodeId,gum::NodeSet const &) const\n"
    "    gum::UndiGraph::hasUndirectedPath(gum::NodeSet const &,gum::NodeSet const &,gum::NodeSet const &) const\n");
  return 0;
}


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] ;
  gum::NodeGraphPart *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 = (gum::NodeGraphPart *) &gum_UndiGraph_nodes((gum::UndiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_nameFromId(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] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph_nameFromId", 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_nameFromId" "', 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_nameFromId" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_UndiGraph_nameFromId((gum::UndiGraph 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_UndiGraph_idFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::optional< gum::NodeId > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph_idFromName", 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_idFromName" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UndiGraph_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UndiGraph_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_UndiGraph_idFromName((gum::UndiGraph const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyLong_FromSize_t((size_t)(&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_setName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *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 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph_setName", 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_setName" "', 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_setName" "', 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 '" "UndiGraph_setName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UndiGraph_setName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_UndiGraph_setName(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_UndiGraph_hasName(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_hasName", 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_hasName" "', 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_hasName" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_UndiGraph_hasName((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_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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_UndiGraph_addNodes((gum::UndiGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  SwigValueWrapper< gum::Set< gum::Edge > > 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_edges" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = gum_UndiGraph_edges((gum::UndiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromEdgeSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_UndiGraph_neighbours((gum::UndiGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< gum::DiGraph > rvrdeleter1 ;
  gum::DiGraph *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiGraph" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "gum::DiGraph &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiGraph" "', argument " "1"" of type '" "gum::DiGraph &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DiGraph" "', argument " "1"" of type '" "gum::DiGraph &&""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    try {
      result = (gum::DiGraph *)new gum::DiGraph((gum::DiGraph &&)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiGraph(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) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_DiGraph__SWIG_6(self, argc, argv);
  }
check_3:
  
  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"
    "    gum::DiGraph::DiGraph(gum::DiGraph &&)\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=PyLong_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 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_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)((gum::DiGraph const *)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_directedPath(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] ;
  std::optional< std::vector< gum::NodeId,std::allocator< gum::NodeId > > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_directedPath", 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_directedPath" "', 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_directedPath" "', 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_directedPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = ((gum::DiGraph const *)arg1)->directedPath(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PyListFromNodeVect((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_directedUnorientedPath(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] ;
  std::optional< std::vector< gum::NodeId,std::allocator< gum::NodeId > > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_directedUnorientedPath", 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_directedUnorientedPath" "', 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_directedUnorientedPath" "', 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_directedUnorientedPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = ((gum::DiGraph const *)arg1)->directedUnorientedPath(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PyListFromNodeVect((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_ancestors__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *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__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_ancestors" "', 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_ancestors" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::DiGraph const *)arg1)->ancestors(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_descendants__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *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__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_descendants" "', 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_descendants" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::DiGraph const *)arg1)->descendants(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_family__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *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__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_family" "', 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_family" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::DiGraph const *)arg1)->family(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_family__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeSet _ns_temp2 ;
  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__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_family" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    try {
      result = ((gum::DiGraph const *)arg1)->family((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_family(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DiGraph_family", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    return _wrap_DiGraph_family__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_DiGraph_family__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 'DiGraph_family'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DiGraph::family(gum::NodeId) const\n"
    "    gum::DiGraph::family(gum::NodeSet const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DiGraph_connectedComponents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *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__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_connectedComponents" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = ((gum::DiGraph const *)arg1)->connectedComponents();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PyDictFromNodePropertyNodeId(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] ;
  gum::NodeGraphPart *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 = (gum::NodeGraphPart *) &gum_DiGraph_nodes((gum::DiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_nameFromId(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] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_nameFromId", 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_nameFromId" "', 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_nameFromId" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_DiGraph_nameFromId((gum::DiGraph 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_DiGraph_idFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::optional< gum::NodeId > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_idFromName", 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_idFromName" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiGraph_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DiGraph_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_DiGraph_idFromName((gum::DiGraph const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyLong_FromSize_t((size_t)(&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_setName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *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 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_setName", 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_setName" "', 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_setName" "', 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 '" "DiGraph_setName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DiGraph_setName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_DiGraph_setName(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_DiGraph_hasName(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_hasName", 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_hasName" "', 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_hasName" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_DiGraph_hasName((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_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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_DiGraph_addNodes((gum::DiGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  SwigValueWrapper< gum::Set< gum::Arc > > 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_arcs" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = gum_DiGraph_arcs((gum::DiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromArcSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_DiGraph_parents((gum::DiGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_DiGraph_children((gum::DiGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_descendants__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *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__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_descendants" "', 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_descendants" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_DiGraph_descendants__SWIG_1((gum::DiGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_descendants(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DiGraph_descendants", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_DiGraph_descendants__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_DiGraph_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 'DiGraph_descendants'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DiGraph::descendants(gum::NodeId) const\n"
    "    gum::DiGraph::descendants(gum::NodeId) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DiGraph_ancestors__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *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__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_ancestors" "', 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_ancestors" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_DiGraph_ancestors__SWIG_1((gum::DiGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_ancestors(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DiGraph_ancestors", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_DiGraph_ancestors__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_DiGraph_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 'DiGraph_ancestors'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DiGraph::ancestors(gum::NodeId) const\n"
    "    gum::DiGraph::ancestors(gum::NodeId) const\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_new_DAG(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) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_DAG__SWIG_6(self, argc, argv);
  }
check_3:
  
  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"
    "    gum::DAG::DAG(gum::DAG &&)\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(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeSet _ns_temp2 ;
  PyObject *swig_obj[2] ;
  gum::UndiGraph result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DAG_moralizedAncestralGraph", 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_moralizedAncestralGraph" "', argument " "1"" of type '" "gum::DAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    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 ;
  gum::NodeSet _ns_temp4 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    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 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  gum::NodeSet _ns_temp4 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    try {
      result = ((gum::DAG const *)arg1)->minimalCondSet(SWIG_STD_MOVE(*(&arg2)),(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  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 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    try {
      result = ((gum::DAG const *)arg1)->minimalCondSet((gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_2;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_2;
    {
      {
        if (PySet_Check(argv[3]) || PyFrozenSet_Check(argv[3])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[3]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        if (PySet_Check(argv[3]) || PyFrozenSet_Check(argv[3])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[3]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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_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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_DAG_addNodes((gum::DAG const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  SwigValueWrapper< gum::Set< gum::Arc > > 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_arcs" "', argument " "1"" of type '" "gum::DAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  {
    try {
      result = gum_DAG_arcs((gum::DAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromArcSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_DAG_parents((gum::DAG const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_DAG_children((gum::DAG const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_descendants(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DAG_descendants", 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_descendants" "', 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_descendants" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_DAG_descendants((gum::DAG const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_ancestors(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DAG_ancestors", 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_ancestors" "', 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_ancestors" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_DAG_ancestors((gum::DAG const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< gum::MixedGraph > rvrdeleter1 ;
  gum::MixedGraph *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedGraph" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "gum::MixedGraph &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedGraph" "', argument " "1"" of type '" "gum::MixedGraph &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MixedGraph" "', argument " "1"" of type '" "gum::MixedGraph &&""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    try {
      result = (gum::MixedGraph *)new gum::MixedGraph((gum::MixedGraph &&)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MixedGraph(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;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_MixedGraph__SWIG_10(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) {
    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_5;
    return _wrap_new_MixedGraph__SWIG_8(self, argc, argv);
  }
check_5:
  
  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"
    "    gum::MixedGraph::MixedGraph(gum::MixedGraph &&)\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 = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_chainComponents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *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__MixedGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGraph_chainComponents" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = ((gum::MixedGraph const *)arg1)->chainComponents();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PyDictFromNodePropertyNodeId(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_connectedComponents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *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__MixedGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGraph_connectedComponents" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = ((gum::MixedGraph const *)arg1)->connectedComponents();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PyDictFromNodePropertyNodeId(result);
  }
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_MixedGraph_addNodes((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  SwigValueWrapper< gum::Set< gum::Arc > > 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_arcs" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = gum_MixedGraph_arcs((gum::MixedGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromArcSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_MixedGraph_parents((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_MixedGraph_children((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_descendants(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_descendants", 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_descendants" "', 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_descendants" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_MixedGraph_descendants((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_ancestors(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_ancestors", 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_ancestors" "', 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_ancestors" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_MixedGraph_ancestors((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  SwigValueWrapper< gum::Set< gum::Edge > > 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_edges" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = gum_MixedGraph_edges((gum::MixedGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromEdgeSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_MixedGraph_neighbours((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_MixedGraph_boundary((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  std::optional< std::vector< gum::NodeId,std::allocator< gum::NodeId > > > result;
  
  (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 = gum_MixedGraph_mixedOrientedPath((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PyListFromNodeVect((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  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] ;
  std::optional< std::vector< gum::NodeId,std::allocator< gum::NodeId > > > result;
  
  (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 = gum_MixedGraph_mixedUnorientedPath((gum::MixedGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PyListFromNodeVect((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  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__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< gum::PDAG > rvrdeleter1 ;
  gum::PDAG *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__PDAG, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PDAG" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "gum::PDAG &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PDAG" "', argument " "1"" of type '" "gum::PDAG &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PDAG" "', argument " "1"" of type '" "gum::PDAG &&""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    try {
      result = (gum::PDAG *)new gum::PDAG((gum::PDAG &&)*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;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PDAG, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_new_PDAG__SWIG_11(self, argc, argv);
  }
check_4:
  
  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_5;
    return _wrap_new_PDAG__SWIG_9(self, argc, argv);
  }
check_5:
  
  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_6;
    return _wrap_new_PDAG__SWIG_7(self, argc, argv);
  }
check_6:
  
  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"
    "    gum::PDAG::PDAG(gum::PDAG &&)\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(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PDAG *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeSet _ns_temp2 ;
  PyObject *swig_obj[2] ;
  gum::UndiGraph result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_moralizedAncestralGraph", 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_moralizedAncestralGraph" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    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 ;
  gum::NodeSet _ns_temp4 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    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 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  gum::NodeSet _ns_temp4 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_2;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_2;
    {
      {
        if (PySet_Check(argv[3]) || PyFrozenSet_Check(argv[3])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[3]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        if (PySet_Check(argv[3]) || PyFrozenSet_Check(argv[3])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[3]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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_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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_PDAG_addNodes((gum::PDAG const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  SwigValueWrapper< gum::Set< gum::Arc > > 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_arcs" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    try {
      result = gum_PDAG_arcs((gum::PDAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromArcSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_PDAG_parents((gum::PDAG const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_PDAG_children((gum::PDAG const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_descendants(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_descendants", 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_descendants" "', 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_descendants" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_PDAG_descendants((gum::PDAG const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDAG_ancestors(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PDAG_ancestors", 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_ancestors" "', 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_ancestors" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_PDAG_ancestors((gum::PDAG const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  SwigValueWrapper< gum::Set< gum::Edge > > 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_edges" "', argument " "1"" of type '" "gum::PDAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PDAG * >(argp1);
  {
    try {
      result = gum_PDAG_edges((gum::PDAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromEdgeSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_PDAG_neighbours((gum::PDAG const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_PDAG_boundary((gum::PDAG const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  std::optional< std::vector< gum::NodeId,std::allocator< gum::NodeId > > > result;
  
  (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 = gum_PDAG_mixedOrientedPath((gum::PDAG const *)arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PyListFromNodeVect((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  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] ;
  std::optional< std::vector< gum::NodeId,std::allocator< gum::NodeId > > > result;
  
  (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 = gum_PDAG_mixedUnorientedPath((gum::PDAG const *)arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PyListFromNodeVect((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  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_PAG__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::PAG *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (gum::PAG *)new gum::PAG();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


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


SWIGINTERN PyObject *_wrap_new_PAG(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PAG", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_PAG__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__PAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_PAG__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_PAG__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_PAG'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::PAG::PAG()\n"
    "    gum::PAG::PAG(gum::PAG const &)\n"
    "    gum::PAG::PAG(gum::PAG &&)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PAG(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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__PAG, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PAG" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_addEdge__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PAG *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__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_addEdge" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_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 '" "PAG_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_PAG_addEdge__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  gum::EdgeMark arg4 ;
  gum::EdgeMark arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_addEdge" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_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 '" "PAG_addEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PAG_addEdge" "', argument " "4"" of type '" "gum::EdgeMark""'");
  } 
  arg4 = static_cast< gum::EdgeMark >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PAG_addEdge" "', argument " "5"" of type '" "gum::EdgeMark""'");
  } 
  arg5 = static_cast< gum::EdgeMark >(val5);
  {
    try {
      (arg1)->addEdge(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),arg4,arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_eraseEdge__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PAG *arg1 = 0 ;
  gum::Edge *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__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_eraseEdge" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(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 '" "PAG_eraseEdge" "', argument " "2"" of type '" "gum::Edge const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PAG_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_PAG_clearEdges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_clearEdges" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  {
    try {
      (arg1)->clearEdges();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_eraseNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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, "PAG_eraseNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_eraseNode" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_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_PAG_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_clear" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_PAG_setMarkAt__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  gum::EdgeMark arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_setMarkAt" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_setMarkAt" "', 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 '" "PAG_setMarkAt" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PAG_setMarkAt" "', argument " "4"" of type '" "gum::EdgeMark""'");
  } 
  arg4 = static_cast< gum::EdgeMark >(val4);
  {
    try {
      (arg1)->setMarkAt(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_PAG_isArrowhead(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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, "PAG_isArrowhead", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_isArrowhead" "', argument " "1"" of type '" "gum::PAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_isArrowhead" "', 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 '" "PAG_isArrowhead" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)((gum::PAG const *)arg1)->isArrowhead(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_PAG_isTail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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, "PAG_isTail", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_isTail" "', argument " "1"" of type '" "gum::PAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_isTail" "', 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 '" "PAG_isTail" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)((gum::PAG const *)arg1)->isTail(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_PAG_isCircle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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, "PAG_isCircle", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_isCircle" "', argument " "1"" of type '" "gum::PAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_isCircle" "', 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 '" "PAG_isCircle" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)((gum::PAG const *)arg1)->isCircle(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_PAG_isDefinitelyDirected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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, "PAG_isDefinitelyDirected", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_isDefinitelyDirected" "', argument " "1"" of type '" "gum::PAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_isDefinitelyDirected" "', 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 '" "PAG_isDefinitelyDirected" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)((gum::PAG const *)arg1)->isDefinitelyDirected(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_PAG_isBidirected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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, "PAG_isBidirected", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_isBidirected" "', argument " "1"" of type '" "gum::PAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_isBidirected" "', 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 '" "PAG_isBidirected" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)((gum::PAG const *)arg1)->isBidirected(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_PAG_isDefCollider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  gum::NodeId 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 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PAG_isDefCollider", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_isDefCollider" "', argument " "1"" of type '" "gum::PAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_isDefCollider" "', 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 '" "PAG_isDefCollider" "', 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 '" "PAG_isDefCollider" "', argument " "4"" of type '" "gum::NodeId""'");
  } 
  arg4 = static_cast< gum::NodeId >(val4);
  {
    try {
      result = (bool)((gum::PAG const *)arg1)->isDefCollider(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),SWIG_STD_MOVE(*(&arg4)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_reorientAllWith__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PAG *arg1 = 0 ;
  gum::EdgeMark 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__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_reorientAllWith" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_reorientAllWith" "', argument " "2"" of type '" "gum::EdgeMark""'");
  } 
  arg2 = static_cast< gum::EdgeMark >(val2);
  {
    try {
      (arg1)->reorientAllWith(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_toMixedGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::MixedGraph result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_toMixedGraph" "', argument " "1"" of type '" "gum::PAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  {
    try {
      result = ((gum::PAG const *)arg1)->toMixedGraph();
    } 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_PAG_toDot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_toDot" "', argument " "1"" of type '" "gum::PAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  {
    try {
      result = ((gum::PAG 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_PAG_addNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_addNode" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  {
    try {
      result = gum_PAG_addNode(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_addNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *arg1 = 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::vector< std::size_t,std::allocator< std::size_t > > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PAG_addNodes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_addNodes" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_addNodes" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = gum_PAG_addNodes(arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PyListFromNodeVect(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_addNodeWithId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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, "PAG_addNodeWithId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_addNodeWithId" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_addNodeWithId" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_PAG_addNodeWithId(arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_existsNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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, "PAG_existsNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_existsNode" "', argument " "1"" of type '" "gum::PAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_existsNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_PAG_existsNode((gum::PAG 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_PAG_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_size" "', argument " "1"" of type '" "gum::PAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  {
    try {
      result = gum_PAG_size((gum::PAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_empty" "', argument " "1"" of type '" "gum::PAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  {
    try {
      result = (bool)gum_PAG_empty((gum::PAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_addEdge__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PAG *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__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_addEdge" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_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 '" "PAG_addEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_PAG_addEdge__SWIG_2(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_PAG_eraseEdge__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PAG *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__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_eraseEdge" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_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 '" "PAG_eraseEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_PAG_eraseEdge__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_PAG_eraseEdge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PAG_eraseEdge", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_PAG_eraseEdge__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_PAG_eraseEdge__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 'PAG_eraseEdge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::PAG::eraseEdge(gum::Edge const &)\n"
    "    gum::PAG::eraseEdge(gum::NodeId const,gum::NodeId const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PAG_existsEdge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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, "PAG_existsEdge", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_existsEdge" "', argument " "1"" of type '" "gum::PAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_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 '" "PAG_existsEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)gum_PAG_existsEdge((gum::PAG 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_PAG_sizeEdges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_sizeEdges" "', argument " "1"" of type '" "gum::PAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  {
    try {
      result = gum_PAG_sizeEdges((gum::PAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_emptyEdges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_emptyEdges" "', argument " "1"" of type '" "gum::PAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  {
    try {
      result = (bool)gum_PAG_emptyEdges((gum::PAG const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_eraseNeighbours(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::PAG *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, "PAG_eraseNeighbours", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_eraseNeighbours" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_eraseNeighbours" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_PAG_eraseNeighbours(arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_addEdge__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_addEdge" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_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 '" "PAG_addEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PAG_addEdge" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PAG_addEdge" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      gum_PAG_addEdge__SWIG_3(arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),arg4,arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_addEdge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PAG_addEdge", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_PAG_addEdge__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_PAG_addEdge__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_PAG_addEdge__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_PAG_addEdge__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 'PAG_addEdge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::PAG::addEdge(gum::NodeId,gum::NodeId)\n"
    "    gum::PAG::addEdge(gum::NodeId,gum::NodeId,gum::EdgeMark,gum::EdgeMark)\n"
    "    gum::PAG::addEdge(gum::NodeId const,gum::NodeId const)\n"
    "    gum::PAG::addEdge(gum::NodeId,gum::NodeId,int,int)\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_PAG_markAt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PAG_markAt", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_PAG_markAt__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_PAG_markAt__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 'PAG_markAt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::PAG::markAt(gum::NodeId,gum::NodeId) const\n"
    "    gum::PAG::markAt(gum::NodeId,gum::NodeId) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PAG_setMarkAt__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_setMarkAt" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_setMarkAt" "', 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 '" "PAG_setMarkAt" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PAG_setMarkAt" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      gum_PAG_setMarkAt__SWIG_1(arg1,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_PAG_setMarkAt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PAG_setMarkAt", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    PyObject *retobj = _wrap_PAG_setMarkAt__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_PAG_setMarkAt__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 'PAG_setMarkAt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::PAG::setMarkAt(gum::NodeId,gum::NodeId,gum::EdgeMark)\n"
    "    gum::PAG::setMarkAt(gum::NodeId,gum::NodeId,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PAG_reorientAllWith__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PAG *arg1 = 0 ;
  int 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__PAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PAG_reorientAllWith" "', argument " "1"" of type '" "gum::PAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::PAG * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PAG_reorientAllWith" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      gum_PAG_reorientAllWith__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PAG_reorientAllWith(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PAG_reorientAllWith", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_PAG_reorientAllWith__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_PAG_reorientAllWith__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 'PAG_reorientAllWith'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::PAG::reorientAllWith(gum::EdgeMark)\n"
    "    gum::PAG::reorientAllWith(int)\n");
  return 0;
}


SWIGINTERN PyObject *PAG_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__PAG, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

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


SWIGINTERN PyObject *_wrap_new_CliqueGraph(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) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_CliqueGraph__SWIG_6(self, argc, argv);
  }
check_3:
  
  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"
    "    gum::CliqueGraph::CliqueGraph(gum::CliqueGraph &&)\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 ;
  gum::NodeSet _ns_temp2 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 = PyAgrumHelper::PyListFromNodeVect(result);
  }
  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_view arg5 ;
  std::string_view arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *bytes5 = NULL ;
  PyObject *bytes6 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[4]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[4]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[4])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[4], &len, &bytes5);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[4]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[4]);
    }
#endif
    arg5 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[5]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[5]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[5])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[5], &len, &bytes6);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[5]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[5]);
    }
#endif
    arg6 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::CliqueGraph const *)arg1)->mapToDot(arg2,arg3,arg4,SWIG_STD_MOVE(*(&arg5)),SWIG_STD_MOVE(*(&arg6)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  
  SWIG_Py_XDECREF(bytes5);
  
  
  SWIG_Py_XDECREF(bytes6);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes5);
  
  
  SWIG_Py_XDECREF(bytes6);
  
  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_view arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *bytes5 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[4]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[4]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[4])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[4], &len, &bytes5);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[4]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[4]);
    }
#endif
    arg5 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::CliqueGraph const *)arg1)->mapToDot(arg2,arg3,arg4,SWIG_STD_MOVE(*(&arg5)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  
  SWIG_Py_XDECREF(bytes5);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes5);
  
  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_view,std::string_view) const\n"
    "    gum::CliqueGraph::mapToDot(double,double,double,std::string_view) 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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_CliqueGraph_clique((gum::CliqueGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_CliqueGraph_separator((gum::CliqueGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  std::vector< gum::Arc,std::allocator< gum::Arc > > *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 = (std::vector< gum::Arc,std::allocator< gum::Arc > > *) &((gum::MeekRules const *)arg1)->choices();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PyListFromArcVect(*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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->erase(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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_view arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,gum::Idx)\n"
    "    gum::Instantiation::chgVal(std::string_view,std::string_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (bool)((gum::Instantiation const *)arg1)->contains(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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 ;
  PyAgrumInstDict *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 = (PyAgrumInstDict *)gum_Instantiation_todict__SWIG_0((gum::Instantiation const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumInstDict *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 = (PyAgrumInstDict *)gum_Instantiation_todict__SWIG_0((gum::Instantiation const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (std::string *) &((gum::GraphicalModel const *)arg1)->property(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_propertyWithDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  std::string_view arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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(SWIG_STD_MOVE(*(&arg2)),(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  
  SWIG_Py_XDECREF(bytes2);
  
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->setProperty(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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] ;
  SwigValueWrapper< 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;
    }
  }
  {
    std::vector<std::string> _v = std::move(result);
    Py_ssize_t _n = static_cast<Py_ssize_t>(_v.size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyUnicode_FromString(_v[_i].c_str()));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_existsProperty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "GraphicalModel_existsProperty", 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_existsProperty" "', argument " "1"" of type '" "gum::GraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (bool)((gum::GraphicalModel const *)arg1)->existsProperty(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_updateMetaData(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, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GraphicalModel_updateMetaData" "', argument " "1"" of type '" "gum::GraphicalModel *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphicalModel * >(argp1);
  {
    try {
      (arg1)->updateMetaData();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (bool)((gum::GraphicalModel const *)arg1)->exists(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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 ;
  SwigValueWrapper< 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;
    }
  }
  {
    std::vector<std::string> _v = std::move(result);
    Py_ssize_t _n = static_cast<Py_ssize_t>(_v.size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyUnicode_FromString(_v[_i].c_str()));
  }
  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 ;
  gum::NodeSet _ns_temp2 ;
  SwigValueWrapper< 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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    try {
      result = ((gum::GraphicalModel const *)arg1)->names((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    std::vector<std::string> _v = std::move(result);
    Py_ssize_t _n = static_cast<Py_ssize_t>(_v.size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyUnicode_FromString(_v[_i].c_str()));
  }
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      result = ((gum::GraphicalModel const *)arg1)->ids((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PyListFromNodeVect(result);
  }
  return resultobj;
fail:
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      result = ((gum::GraphicalModel const *)arg1)->nodeset((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    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 );
  return resultobj;
fail:
  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 ;
  gum::NodeSet _ns_temp2 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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 = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::GraphicalModel const *)arg1)->idFromName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_GraphicalModel_variableFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphicalModel *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::GraphicalModel const *)arg1)->variableFromName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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 ;
  gum::NodeSet _ns_temp4 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    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 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  gum::NodeSet _ns_temp4 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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_spaceCplxToString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  gum::Size arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "GraphicalModel_spaceCplxToString", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GraphicalModel_spaceCplxToString" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GraphicalModel_spaceCplxToString" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GraphicalModel_spaceCplxToString" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  {
    try {
      result = gum::GraphicalModel::spaceCplxToString(arg1,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_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 = PyAgrumHelper::PySetFromNodeSet(result);
  }
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::GraphicalModel const *)arg1)->family(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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_DiscreteGraphicalModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteGraphicalModel *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__DiscreteGraphicalModel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscreteGraphicalModel" "', argument " "1"" of type '" "gum::DiscreteGraphicalModel *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteGraphicalModel * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteGraphicalModel_variableNodeMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteGraphicalModel *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__DiscreteGraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteGraphicalModel_variableNodeMap" "', argument " "1"" of type '" "gum::DiscreteGraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteGraphicalModel * >(argp1);
  {
    try {
      result = (gum::VariableNodeMap *) &((gum::DiscreteGraphicalModel 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_DiscreteGraphicalModel_variable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteGraphicalModel *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, "DiscreteGraphicalModel_variable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteGraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteGraphicalModel_variable" "', argument " "1"" of type '" "gum::DiscreteGraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteGraphicalModel * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscreteGraphicalModel_variable" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::DiscreteGraphicalModel 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_DiscreteGraphicalModel_nodeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteGraphicalModel *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, "DiscreteGraphicalModel_nodeId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteGraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteGraphicalModel_nodeId" "', argument " "1"" of type '" "gum::DiscreteGraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteGraphicalModel * >(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 '" "DiscreteGraphicalModel_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DiscreteGraphicalModel_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = ((gum::DiscreteGraphicalModel 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_DiscreteGraphicalModel_idFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteGraphicalModel *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DiscreteGraphicalModel_idFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteGraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteGraphicalModel_idFromName" "', argument " "1"" of type '" "gum::DiscreteGraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteGraphicalModel * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::DiscreteGraphicalModel const *)arg1)->idFromName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteGraphicalModel_variableFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteGraphicalModel *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DiscreteGraphicalModel_variableFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteGraphicalModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteGraphicalModel_variableFromName" "', argument " "1"" of type '" "gum::DiscreteGraphicalModel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteGraphicalModel * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::DiscreteGraphicalModel const *)arg1)->variableFromName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *DiscreteGraphicalModel_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__DiscreteGraphicalModel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

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


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_new_DAGmodel__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::DAGmodel *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_DAGmodel" "', argument " "1"" of type '" "gum::DAGmodel const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DAGmodel" "', argument " "1"" of type '" "gum::DAGmodel const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = (gum::DAGmodel *)new gum::DAGmodel((gum::DAGmodel const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DAGmodel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_DAGmodel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DAGmodel", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_DAGmodel__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_DAGmodel__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DAGmodel__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_DAGmodel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAGmodel::DAGmodel()\n"
    "    gum::DAGmodel::DAGmodel(gum::DAGmodel const &)\n"
    "    gum::DAGmodel::DAGmodel(gum::DAGmodel &&)\n");
  return 0;
}


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;
  
  (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::DAGmodel 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_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 = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (bool)((gum::DAGmodel const *)arg1)->exists(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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 = PyAgrumHelper::PySetFromArcSet(*result);
  }
  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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    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));
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view) 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 = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::NodeSet *) &((gum::DAGmodel const *)arg1)->parents(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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 ;
  gum::NodeSet _ns_temp2 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->parents((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->parents((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[1]);
#else
      _v = PyUnicode_Check(argv[1]) || PyBytes_Check(argv[1]);
#endif
    }
    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_view) 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 = PyAgrumHelper::PySetFromNodeSet(result);
  }
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->family(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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 = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::NodeSet *) &((gum::DAGmodel const *)arg1)->children(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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 ;
  gum::NodeSet _ns_temp2 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->children((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->children((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[1]);
#else
      _v = PyUnicode_Check(argv[1]) || PyBytes_Check(argv[1]);
#endif
    }
    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_view) 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 = PyAgrumHelper::PySetFromNodeSet(result);
  }
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->descendants(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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 = PyAgrumHelper::PySetFromNodeSet(result);
  }
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->ancestors(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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 ;
  gum::NodeSet _ns_temp2 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs2 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    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 );
  return resultobj;
fail:
  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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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 ;
  gum::NodeSet _ns_temp4 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    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 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  gum::NodeSet _ns_temp4 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    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_view arg2 ;
  std::string_view arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  std::vector< std::string > _tmp_vs4 ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[3]) || PyUnicode_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[3]);
    _tmp_vs4.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[3], _i);
      if (!_item) SWIG_fail;
      _tmp_vs4.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg4 = &_tmp_vs4;
  }
  {
    try {
      result = (bool)((gum::DAGmodel const *)arg1)->isIndependent(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  std::vector< std::string > _tmp_vs3 ;
  std::vector< std::string > _tmp_vs4 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    if (!PySequence_Check(swig_obj[3]) || PyUnicode_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[3]);
    _tmp_vs4.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[3], _i);
      if (!_item) SWIG_fail;
      _tmp_vs4.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg4 = &_tmp_vs4;
  }
  {
    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));
  return resultobj;
fail:
  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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    {
      {
        if (PySet_Check(argv[3]) || PyFrozenSet_Check(argv[3])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[3]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        if (PySet_Check(argv[3]) || PyFrozenSet_Check(argv[3])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[3]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_2;
    return _wrap_DAGmodel_isIndependent__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 4) {
    int _v = 0;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[1]);
#else
      _v = PyUnicode_Check(argv[1]) || PyBytes_Check(argv[1]);
#endif
    }
    if (!_v) goto check_3;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[2]);
#else
      _v = PyUnicode_Check(argv[2]) || PyBytes_Check(argv[2]);
#endif
    }
    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_view,std::string_view,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=PyLong_FromLong(i);
      PyList_Append(q,pyval);
      Py_DecRef(pyval);
    }
    resultobj=q;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_connectedComponents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *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__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_connectedComponents" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->connectedComponents();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PyDictFromNodePropertyNodeId(result);
  }
  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 const *""'"); 
  }
  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)((gum::DAGmodel 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_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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->minimalCondSet(SWIG_STD_MOVE(*(&arg2)),(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  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 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->minimalCondSet((gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  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_view arg2 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  std::vector< std::string > _tmp_vs3 ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->minimalCondSet(SWIG_STD_MOVE(*(&arg2)),(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  std::vector< std::string > _tmp_vs3 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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 = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_2;
    return _wrap_DAGmodel_minimalCondSet__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[1]);
#else
      _v = PyUnicode_Check(argv[1]) || PyBytes_Check(argv[1]);
#endif
    }
    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_view,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 *DAGmodel_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

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


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


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


SWIGINTERN PyObject *_wrap_new_UGmodel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UGmodel", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_UGmodel__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__UGmodel, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_UGmodel__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_UGmodel__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_UGmodel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UGmodel::UGmodel()\n"
    "    gum::UGmodel::UGmodel(gum::UGmodel const &)\n"
    "    gum::UGmodel::UGmodel(gum::UGmodel &&)\n");
  return 0;
}


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;
  
  (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::UGmodel const *)arg1)->graph();
    } 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_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 = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (bool)((gum::UGmodel const *)arg1)->exists(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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 = PyAgrumHelper::PySetFromEdgeSet(*result);
  }
  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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    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));
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view) 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 = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::NodeSet *) &((gum::UGmodel const *)arg1)->neighbours(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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 ;
  gum::NodeSet _ns_temp4 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    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 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  gum::NodeSet _ns_temp4 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    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_view arg2 ;
  std::string_view arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  std::vector< std::string > _tmp_vs4 ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[3]) || PyUnicode_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[3]);
    _tmp_vs4.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[3], _i);
      if (!_item) SWIG_fail;
      _tmp_vs4.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg4 = &_tmp_vs4;
  }
  {
    try {
      result = (bool)((gum::UGmodel const *)arg1)->isIndependent(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  std::vector< std::string > _tmp_vs3 ;
  std::vector< std::string > _tmp_vs4 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    if (!PySequence_Check(swig_obj[3]) || PyUnicode_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[3]);
    _tmp_vs4.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[3], _i);
      if (!_item) SWIG_fail;
      _tmp_vs4.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg4 = &_tmp_vs4;
  }
  {
    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));
  return resultobj;
fail:
  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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    {
      {
        if (PySet_Check(argv[3]) || PyFrozenSet_Check(argv[3])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[3]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        if (PySet_Check(argv[3]) || PyFrozenSet_Check(argv[3])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[3]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_2;
    return _wrap_UGmodel_isIndependent__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 4) {
    int _v = 0;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[1]);
#else
      _v = PyUnicode_Check(argv[1]) || PyBytes_Check(argv[1]);
#endif
    }
    if (!_v) goto check_3;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[2]);
#else
      _v = PyUnicode_Check(argv[2]) || PyBytes_Check(argv[2]);
#endif
    }
    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_view,std::string_view,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 const *""'"); 
  }
  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)((gum::UGmodel const *)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_connectedComponents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::UGmodel *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__UGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UGmodel_connectedComponents" "', argument " "1"" of type '" "gum::UGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UGmodel * >(argp1);
  {
    try {
      result = ((gum::UGmodel const *)arg1)->connectedComponents();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PyDictFromNodePropertyNodeId(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 = PyAgrumHelper::PySetFromNodeSet(result);
  }
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::UGmodel const *)arg1)->family(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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 *UGmodel_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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_view arg2 ;
  PyObject *bytes2 = NULL ;
  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;
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\n"
    "    gum::fastVariable< double >(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fastDiGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  PyObject *swig_obj[1] ;
  gum::DiGraph result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR fastGraph< gum::DiGraph >(SWIG_STD_MOVE(*(&arg1)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::DiGraph(result)), SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_fastUndiGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  PyObject *swig_obj[1] ;
  gum::UndiGraph result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR fastGraph< gum::UndiGraph >(SWIG_STD_MOVE(*(&arg1)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(result)), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_fastMixedGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  PyObject *swig_obj[1] ;
  gum::MixedGraph result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR fastGraph< gum::MixedGraph >(SWIG_STD_MOVE(*(&arg1)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::MixedGraph(result)), SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_fastDAG(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  PyObject *swig_obj[1] ;
  gum::DAG result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR fastGraph< gum::DAG >(SWIG_STD_MOVE(*(&arg1)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::DAG(result)), SWIGTYPE_p_gum__DAG, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_fastPDAG(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  PyObject *swig_obj[1] ;
  gum::PDAG result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR fastGraph< gum::PDAG >(SWIG_STD_MOVE(*(&arg1)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::PDAG(result)), SWIGTYPE_p_gum__PDAG, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_randomDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< 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;
    }
  }
  {
    std::vector<double> _v = std::move(result);
    Py_ssize_t _n = static_cast<Py_ssize_t>(_v.size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble(_v[_i]));
  }
  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_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  gum::DiscretizedVariable< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::DiscretizedVariable< double > *)new gum::DiscretizedVariable< double >(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscretizedVariableT_double_t, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretizedVariable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  bool arg4 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  std::vector< double > _tmp_vd3 ;
  bool val4 ;
  int ecode4 = 0 ;
  gum::DiscretizedVariable< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  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 >(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretizedVariable__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  std::vector< double > _tmp_vd3 ;
  gum::DiscretizedVariable< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    try {
      result = (gum::DiscretizedVariable< double > *)new gum::DiscretizedVariable< double >(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,std::string_view)\n"
    "    gum::DiscretizedVariable< double >::DiscretizedVariable(std::string_view,std::string_view,std::vector< double,std::allocator< double > > const &,bool)\n"
    "    gum::DiscretizedVariable< double >::DiscretizedVariable(std::string_view,std::string_view,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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::DiscretizedVariable< double > const *)arg1)->index(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double > _tmp_vd2 ;
  
  (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_populate" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vd2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd2.push_back(_val);
    }
    arg2 = &_tmp_vd2;
  }
  {
    try {
      ((gum::MultiDimContainer< double > const *)arg1)->populate((std::vector< double,std::allocator< double > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_populate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = 0 ;
  SwigValueWrapper< std::initializer_list< double > > 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__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_populate" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  
  {
    try {
      ((gum::MultiDimContainer< double > const *)arg1)->populate(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_populate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MultiDimContainer_populate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      
    }
    if (!_v) goto check_1;
    return _wrap_MultiDimContainer_populate__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MultiDimContainer_populate__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_populate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MultiDimContainer< double >::populate(std::vector< double,std::allocator< double > > const &) const\n"
    "    gum::MultiDimContainer< double >::populate(std::initializer_list< double >) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_copyFrom__SWIG_0(PyObject *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_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 = 0 ;
  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 = 0 ;
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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 = 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__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_mean(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_mean" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (double)((gum::Tensor< double > const *)arg1)->mean();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_variance(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_variance" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (double)((gum::Tensor< double > const *)arg1)->variance();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Tensor_stdDev(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_stdDev" "', argument " "1"" of type '" "gum::Tensor< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  {
    try {
      result = (double)((gum::Tensor< double > const *)arg1)->stdDev();
    } 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 ;
  std::vector< std::string > _tmp_vs2 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    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 );
  return resultobj;
fail:
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::Tensor< double > const *)arg1)->putFirst(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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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 ;
  std::vector< std::string > _tmp_vs3 ;
  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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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 );
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd2 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vd2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd2.push_back(_val);
    }
    arg2 = &_tmp_vd2;
  }
  {
    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 );
  return resultobj;
fail:
  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 ;
  PyAgrumFloat *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 = (PyAgrumFloat *)gum_Tensor_Sl_double_Sg__expectedValue__SWIG_1((gum::Tensor< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumArgMinMax *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 = (PyAgrumArgMinMax *)gum_Tensor_Sl_double_Sg__argmin(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumArgMinMax *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 = (PyAgrumArgMinMax *)gum_Tensor_Sl_double_Sg__argmax(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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__as_nparray_raw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyAgrumNdArray *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor__as_nparray_raw", 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__as_nparray_raw" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyAgrumNdArray *)gum_Tensor_Sl_double_Sg___as_nparray_raw(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_Tensor__fillWithNpArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Tensor< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyAgrumNone *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Tensor__fillWithNpArray", 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__fillWithNpArray" "', argument " "1"" of type '" "gum::Tensor< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Tensor< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyAgrumNone *)gum_Tensor_Sl_double_Sg___fillWithNpArray(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


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 = 0 ;
  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_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *bytes3 = NULL ;
  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 *""'"); 
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->whenStop((void const *)arg2,SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *bytes3 = NULL ;
  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 *""'"); 
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->whenStop((void const *)arg2,SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  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] ;
  PyAgrumBool *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 = (PyAgrumBool *)(arg1)->isType(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumBool *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 = (PyAgrumBool *)(arg1)->isClass(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumBool *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 = (PyAgrumBool *)(arg1)->isInterface(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumListOfStr *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 = (PyAgrumListOfStr *)(arg1)->classes();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumList *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 = (PyAgrumList *)(arg1)->classAttributes(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumBool *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 = (PyAgrumBool *)(arg1)->isAttribute(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumList *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 = (PyAgrumList *)(arg1)->classReferences(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumListOfStr *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 = (PyAgrumListOfStr *)(arg1)->classParameters(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumListOfStr *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 = (PyAgrumListOfStr *)(arg1)->classImplements(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumList *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 = (PyAgrumList *)(arg1)->classAggregates(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumList *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 = (PyAgrumList *)(arg1)->classSlotChains(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumList *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 = (PyAgrumList *)(arg1)->getalltheSystems();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumStr *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 = (PyAgrumStr *)(arg1)->getSuperClass(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumListOfStr *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 = (PyAgrumListOfStr *)(arg1)->getDirectSubClass(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumListOfStr *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 = (PyAgrumListOfStr *)(arg1)->types();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumStr *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 = (PyAgrumStr *)(arg1)->getSuperType(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumListOfStr *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 = (PyAgrumListOfStr *)(arg1)->getDirectSubTypes(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumListOfStr *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 = (PyAgrumListOfStr *)(arg1)->getLabels(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumListOfStr *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 = (PyAgrumListOfStr *)(arg1)->interfaces();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumList *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 = (PyAgrumList *)(arg1)->interAttributes(SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumList *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 = (PyAgrumList *)(arg1)->interAttributes(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumList *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 = (PyAgrumList *)(arg1)->interReferences(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumStr *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 = (PyAgrumStr *)(arg1)->getSuperInterface(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumListOfStr *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 = (PyAgrumListOfStr *)(arg1)->getDirectSubInterfaces(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumListOfStr *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 = (PyAgrumListOfStr *)(arg1)->getImplementations(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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_descendants__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *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__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_descendants" "', 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_descendants" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::EssentialGraph const *)arg1)->descendants(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_ancestors__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *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__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_ancestors" "', 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_ancestors" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::EssentialGraph const *)arg1)->ancestors(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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_connectedComponents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *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__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_connectedComponents" "', argument " "1"" of type '" "gum::EssentialGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = ((gum::EssentialGraph const *)arg1)->connectedComponents();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PyDictFromNodePropertyNodeId(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_idFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::EssentialGraph const *)arg1)->idFromName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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] ;
  gum::NodeGraphPart *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 = (gum::NodeGraphPart *) &gum_EssentialGraph_nodes((gum::EssentialGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*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] ;
  SwigValueWrapper< gum::Set< gum::Arc > > 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_arcs" "', argument " "1"" of type '" "gum::EssentialGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = gum_EssentialGraph_arcs((gum::EssentialGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromArcSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_EssentialGraph_parents((gum::EssentialGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_EssentialGraph_children((gum::EssentialGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_descendants__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *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__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_descendants" "', 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_descendants" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_EssentialGraph_descendants__SWIG_1((gum::EssentialGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_descendants(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "EssentialGraph_descendants", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_EssentialGraph_descendants__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_EssentialGraph_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 'EssentialGraph_descendants'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::EssentialGraph::descendants(gum::NodeId) const\n"
    "    gum::EssentialGraph::descendants(gum::NodeId) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_ancestors__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *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__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_ancestors" "', 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_ancestors" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_EssentialGraph_ancestors__SWIG_1((gum::EssentialGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_ancestors(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "EssentialGraph_ancestors", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_EssentialGraph_ancestors__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_EssentialGraph_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 'EssentialGraph_ancestors'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::EssentialGraph::ancestors(gum::NodeId) const\n"
    "    gum::EssentialGraph::ancestors(gum::NodeId) const\n");
  return 0;
}


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] ;
  SwigValueWrapper< gum::Set< gum::Edge > > 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_edges" "', argument " "1"" of type '" "gum::EssentialGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = gum_EssentialGraph_edges((gum::EssentialGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromEdgeSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_EssentialGraph_neighbours((gum::EssentialGraph const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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_view arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,int)\n"
    "    gum::MarkovBlanket::MarkovBlanket(gum::DAGmodel const &,std::string_view)\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_descendants__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *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__MarkovBlanket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovBlanket_descendants" "', 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_descendants" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::MarkovBlanket const *)arg1)->descendants(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_ancestors__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *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__MarkovBlanket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovBlanket_ancestors" "', 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_ancestors" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::MarkovBlanket const *)arg1)->ancestors(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  gum::NodeGraphPart *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 = (gum::NodeGraphPart *) &gum_MarkovBlanket_nodes((gum::MarkovBlanket const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*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] ;
  SwigValueWrapper< gum::Set< gum::Arc > > 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_arcs" "', argument " "1"" of type '" "gum::MarkovBlanket const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovBlanket * >(argp1);
  {
    try {
      result = gum_MarkovBlanket_arcs((gum::MarkovBlanket const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromArcSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_MarkovBlanket_parents((gum::MarkovBlanket const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (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 = gum_MarkovBlanket_children((gum::MarkovBlanket const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_descendants__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *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__MarkovBlanket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovBlanket_descendants" "', 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_descendants" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_MarkovBlanket_descendants__SWIG_1((gum::MarkovBlanket const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_descendants(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovBlanket_descendants", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovBlanket_descendants__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovBlanket_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 'MarkovBlanket_descendants'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovBlanket::descendants(gum::NodeId) const\n"
    "    gum::MarkovBlanket::descendants(gum::NodeId) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_ancestors__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *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__MarkovBlanket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovBlanket_ancestors" "', 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_ancestors" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_MarkovBlanket_ancestors__SWIG_1((gum::MarkovBlanket const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_ancestors(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovBlanket_ancestors", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovBlanket_ancestors__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovBlanket_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 'MarkovBlanket_ancestors'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovBlanket::ancestors(gum::NodeId) const\n"
    "    gum::MarkovBlanket::ancestors(gum::NodeId) const\n");
  return 0;
}


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_StructuralMetrics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_StructuralMetrics", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (gum::StructuralMetrics *)new gum::StructuralMetrics();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__StructuralMetrics, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StructuralMetrics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StructuralMetrics" "', argument " "1"" of type '" "gum::StructuralMetrics *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_compare__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_compare" "', argument " "1"" of type '" "gum::StructuralMetrics *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(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 '" "StructuralMetrics_compare" "', argument " "2"" of type '" "gum::DiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StructuralMetrics_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 '" "StructuralMetrics_compare" "', argument " "3"" of type '" "gum::DiGraph const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StructuralMetrics_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_StructuralMetrics_compare__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_compare" "', argument " "1"" of type '" "gum::StructuralMetrics *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(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 '" "StructuralMetrics_compare" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StructuralMetrics_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 '" "StructuralMetrics_compare" "', argument " "3"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StructuralMetrics_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_StructuralMetrics_compare__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_compare" "', argument " "1"" of type '" "gum::StructuralMetrics *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(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 '" "StructuralMetrics_compare" "', argument " "2"" of type '" "gum::PDAG const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StructuralMetrics_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 '" "StructuralMetrics_compare" "', argument " "3"" of type '" "gum::PDAG const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StructuralMetrics_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_StructuralMetrics_tp_skeleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_tp_skeleton" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->tp_skeleton();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_fp_skeleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_fp_skeleton" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->fp_skeleton();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_fn_skeleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_fn_skeleton" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->fn_skeleton();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_tn_skeleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_tn_skeleton" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->tn_skeleton();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_precision_skeleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_precision_skeleton" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->precision_skeleton();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_recall_skeleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_recall_skeleton" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->recall_skeleton();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_f_score_skeleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_f_score_skeleton" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics 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_StructuralMetrics_shd_skeleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_shd_skeleton" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->shd_skeleton();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_tp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_tp" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->tp();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_fp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_fp" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->fp();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_fn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_fn" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->fn();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_tn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_tn" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->tn();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_precision(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_precision" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->precision();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_recall(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_recall" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->recall();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_f_score(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_f_score" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->f_score();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_shd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_shd" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(argp1);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->shd();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_sid__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *arg1 = 0 ;
  gum::DAG *arg2 = 0 ;
  gum::DAG *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_sid" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(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 '" "StructuralMetrics_sid" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StructuralMetrics_sid" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DAG * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__DAG,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StructuralMetrics_sid" "', argument " "3"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StructuralMetrics_sid" "', argument " "3"" of type '" "gum::DAG const &""'"); 
  }
  arg3 = reinterpret_cast< gum::DAG * >(argp3);
  {
    try {
      result = (double)((gum::StructuralMetrics const *)arg1)->sid((gum::DAG const &)*arg2,(gum::DAG const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_compare__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *arg1 = 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  gum::BayesNet< double > *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_compare" "', argument " "1"" of type '" "gum::StructuralMetrics *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(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 '" "StructuralMetrics_compare" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StructuralMetrics_compare" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StructuralMetrics_compare" "', argument " "3"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StructuralMetrics_compare" "', argument " "3"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg3 = reinterpret_cast< gum::BayesNet< double > * >(argp3);
  {
    try {
      gum_StructuralMetrics_compare__SWIG_3(arg1,(gum::BayesNet< double > const &)*arg2,(gum::BayesNet< double > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_compare(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StructuralMetrics_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_StructuralMetrics_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_StructuralMetrics_compare__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_StructuralMetrics_compare__SWIG_0(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_StructuralMetrics_compare__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 'StructuralMetrics_compare'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::StructuralMetrics::compare(gum::DiGraph const &,gum::DiGraph const &)\n"
    "    gum::StructuralMetrics::compare(gum::UndiGraph const &,gum::UndiGraph const &)\n"
    "    gum::StructuralMetrics::compare(gum::PDAG const &,gum::PDAG const &)\n"
    "    gum::StructuralMetrics::compare(gum::BayesNet< double > const &,gum::BayesNet< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_sid__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::StructuralMetrics *arg1 = 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  gum::BayesNet< double > *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__StructuralMetrics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralMetrics_sid" "', argument " "1"" of type '" "gum::StructuralMetrics const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralMetrics * >(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 '" "StructuralMetrics_sid" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StructuralMetrics_sid" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StructuralMetrics_sid" "', argument " "3"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StructuralMetrics_sid" "', argument " "3"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg3 = reinterpret_cast< gum::BayesNet< double > * >(argp3);
  {
    try {
      result = (double)gum_StructuralMetrics_sid__SWIG_1((gum::StructuralMetrics const *)arg1,(gum::BayesNet< double > const &)*arg2,(gum::BayesNet< double > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralMetrics_sid(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StructuralMetrics_sid", 0, 3, argv))) SWIG_fail;
  --argc;
  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_1;
    {
      int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_StructuralMetrics_sid__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_StructuralMetrics_sid__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 'StructuralMetrics_sid'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::StructuralMetrics::sid(gum::DAG const &,gum::DAG const &) const\n"
    "    gum::StructuralMetrics::sid(gum::BayesNet< double > const &,gum::BayesNet< double > const &) const\n");
  return 0;
}


SWIGINTERN PyObject *StructuralMetrics_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__StructuralMetrics, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StructuralMetrics_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_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] ;
  SwigValueWrapper< 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;
    }
  }
  {
    std::vector<std::string> _v = std::move(result);
    Py_ssize_t _n = static_cast<Py_ssize_t>(_v.size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyUnicode_FromString(_v[_i].c_str()));
  }
  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_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_view arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_evIn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  std::string_view arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_evLt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  std::string_view arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_evGt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  std::string_view arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Tensor< double >(result)), SWIGTYPE_p_gum__TensorT_double_t, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  PyObject *swig_obj[2] ;
  PyAgrumListOfInt *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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      result = (PyAgrumListOfInt *)gum_IBayesNet_Sl_double_Sg__ids(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  PyObject *swig_obj[2] ;
  PyAgrumSetOfInt *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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      result = (PyAgrumSetOfInt *)gum_IBayesNet_Sl_double_Sg__nodeset(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  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 ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_IBayesNet_Sl_double_Sg__minimalCondSet__SWIG_0((gum::IBayesNet< double > const *)arg1,SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_IBayesNet_Sl_double_Sg__minimalCondSet__SWIG_1((gum::IBayesNet< double > const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfStr *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 = (PyAgrumSetOfStr *)gum_IBayesNet_Sl_double_Sg__names((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  gum::NodeGraphPart *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 = (gum::NodeGraphPart *) &gum_IBayesNet_Sl_double_Sg__nodes((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*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] ;
  PyAgrumSetOfArc *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 = (PyAgrumSetOfArc *)gum_IBayesNet_Sl_double_Sg__arcs((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_IBayesNet_Sl_double_Sg__parents((gum::IBayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_IBayesNet_Sl_double_Sg__children((gum::IBayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_IBayesNet_Sl_double_Sg__family((gum::IBayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_IBayesNet_Sl_double_Sg__descendants((gum::IBayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_IBayesNet_Sl_double_Sg__ancestors((gum::IBayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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_view arg1 ;
  gum::Size arg2 ;
  PyObject *bytes1 = NULL ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::BayesNet< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_fastPrototype__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  gum::BayesNet< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = gum::BayesNet< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype(SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_fastPrototype__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  gum::BayesNet< double > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      result = gum::BayesNet< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype(SWIG_STD_MOVE(*(&arg1)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(result)), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  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_view,gum::Size)\n"
    "    gum::BayesNet< double >::fastPrototype(std::string_view,std::string_view)\n"
    "    gum::BayesNet< double >::fastPrototype(std::string_view)\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_view arg1 ;
  PyObject *bytes1 = NULL ;
  gum::BayesNet< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  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__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< gum::BayesNet< double > > rvrdeleter1 ;
  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, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BayesNet" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "gum::BayesNet< double > &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BayesNet" "', argument " "1"" of type '" "gum::BayesNet< double > &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_BayesNet" "', argument " "1"" of type '" "gum::BayesNet< double > &&""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    try {
      result = (gum::BayesNet< double > *)new gum::BayesNet< double >((gum::BayesNet< double > &&)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_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) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_BayesNet__SWIG_3(self, argc, argv);
  }
check_3:
  
  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_view)\n"
    "    gum::BayesNet< double >::BayesNet(gum::BayesNet< double > const &)\n"
    "    gum::BayesNet< double >::BayesNet(gum::BayesNet< double > &&)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) const\n");
  return 0;
}


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_view arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (arg1)->add(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,unsigned int)\n"
    "    gum::BayesNet< double >::add(std::string_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->erase(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


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_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *bytes3 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->changeVariableName(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->changeVariableName(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view)\n"
    "    gum::BayesNet< double >::changeVariableName(std::string_view,std::string_view)\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_view arg3 ;
  std::string_view arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *bytes3 = NULL ;
  PyObject *bytes4 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[3]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[3]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[3])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[3], &len, &bytes4);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[3]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[3]);
    }
#endif
    arg4 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->changeVariableLabel(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),SWIG_STD_MOVE(*(&arg4)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes3);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  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_view arg2 ;
  std::string_view arg3 ;
  std::string_view arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  PyObject *bytes4 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[3]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[3]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[3])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[3], &len, &bytes4);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[3]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[3]);
    }
#endif
    arg4 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->changeVariableLabel(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),SWIG_STD_MOVE(*(&arg4)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  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_view,std::string_view)\n"
    "    gum::BayesNet< double >::changeVariableLabel(std::string_view,std::string_view,std::string_view)\n");
  return 0;
}


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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->addArc(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view)\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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->eraseArc(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view)\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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->reverseArc(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view)\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_view arg2 ;
  std::string_view arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  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();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view,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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      ((gum::BayesNet< double > const *)arg1)->generateCPT(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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_view arg2 ;
  gum::Tensor< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,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;
  
  (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::BayesNet< double > 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_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_idFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::BayesNet< double > const *)arg1)->idFromName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


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_variable__SWIG_1(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(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_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_variable__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_variable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::variable(std::string_view) const\n"
    "    gum::BayesNet< double >::variable(gum::NodeId) 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_variableFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::BayesNet< double > const *)arg1)->variableFromName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  PyObject *swig_obj[2] ;
  PyAgrumListOfInt *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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      result = (PyAgrumListOfInt *)gum_BayesNet_Sl_double_Sg__ids(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  PyObject *swig_obj[2] ;
  PyAgrumSetOfInt *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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      result = (PyAgrumSetOfInt *)gum_BayesNet_Sl_double_Sg__nodeset(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  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 ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_BayesNet_Sl_double_Sg__minimalCondSet__SWIG_0((gum::BayesNet< double > const *)arg1,SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_BayesNet_Sl_double_Sg__minimalCondSet__SWIG_1((gum::BayesNet< double > const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfStr *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 = (PyAgrumSetOfStr *)gum_BayesNet_Sl_double_Sg__names((gum::BayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  gum::NodeGraphPart *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 = (gum::NodeGraphPart *) &gum_BayesNet_Sl_double_Sg__nodes((gum::BayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*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] ;
  PyAgrumSetOfArc *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 = (PyAgrumSetOfArc *)gum_BayesNet_Sl_double_Sg__arcs((gum::BayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_BayesNet_Sl_double_Sg__parents((gum::BayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_BayesNet_Sl_double_Sg__children((gum::BayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_BayesNet_Sl_double_Sg__family((gum::BayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_BayesNet_Sl_double_Sg__descendants((gum::BayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_BayesNet_Sl_double_Sg__ancestors((gum::BayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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_loadGUM__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 ;
  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_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadGUM" "', 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_loadGUM" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  arg3 = swig_obj[2];
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BayesNet_loadGUM" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      gum_BayesNet_Sl_double_Sg__loadGUM__SWIG_0(arg1,SWIG_STD_MOVE(*(&arg2)),arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadGUM__SWIG_1(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 ;
  
  (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_loadGUM" "', 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_loadGUM" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  arg3 = swig_obj[2];
  {
    try {
      gum_BayesNet_Sl_double_Sg__loadGUM__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_loadGUM__SWIG_2(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_loadGUM" "', 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_loadGUM" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_BayesNet_Sl_double_Sg__loadGUM__SWIG_0(arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadGUM(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_loadGUM", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet_loadGUM__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet_loadGUM__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BayesNet_loadGUM__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_loadGUM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::loadGUM(std::string,PyObject *,bool)\n"
    "    gum::BayesNet< double >::loadGUM(std::string,PyObject *)\n"
    "    gum::BayesNet< double >::loadGUM(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet__saveGUM__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int 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__saveGUM" "', 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__saveGUM" "', 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__saveGUM" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BayesNet__saveGUM" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveGUM__SWIG_0(arg1,SWIG_STD_MOVE(*(&arg2)),arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet__saveGUM__SWIG_1(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__saveGUM" "', 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__saveGUM" "', 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__saveGUM" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveGUM__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__saveGUM__SWIG_2(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__saveGUM" "', 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__saveGUM" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveGUM__SWIG_0(arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet__saveGUM(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet__saveGUM", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet__saveGUM__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_BayesNet__saveGUM__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_BayesNet__saveGUM__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__saveGUM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::saveGUM(std::string,bool,int)\n"
    "    gum::BayesNet< double >::saveGUM(std::string,bool)\n"
    "    gum::BayesNet< double >::saveGUM(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet__saveGUMstring__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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__saveGUMstring" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNet__saveGUMstring" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__saveGUMstring__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet__saveGUMstring__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< 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__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet__saveGUMstring" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__saveGUMstring__SWIG_0(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet__saveGUMstring(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet__saveGUMstring", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_BayesNet__saveGUMstring__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_BayesNet__saveGUMstring__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__saveGUMstring'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::saveGUMstring(int)\n"
    "    gum::BayesNet< double >::saveGUMstring()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadGUMstring(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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_loadGUMstring", 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_loadGUMstring" "', 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_loadGUMstring" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BayesNet_loadGUMstring" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_BayesNet_Sl_double_Sg__loadGUMstring(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_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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::BayesNetFragment< double > const *)arg1)->idFromName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetFragment_variableFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetFragment< double > *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::BayesNetFragment< double > const *)arg1)->variableFromName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->installNode(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->installAscendants(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->uninstallNode(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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_view arg2 ;
  gum::Tensor< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,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_view arg2 ;
  gum::Tensor< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->uninstallCPT(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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;
  
  (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::BayesNetFragment< double > 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_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 ;
  std::vector< std::string > _tmp_vs2 ;
  PyObject *swig_obj[2] ;
  PyAgrumListOfInt *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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      result = (PyAgrumListOfInt *)gum_BayesNetFragment_Sl_double_Sg__ids(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  PyObject *swig_obj[2] ;
  PyAgrumSetOfInt *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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      result = (PyAgrumSetOfInt *)gum_BayesNetFragment_Sl_double_Sg__nodeset(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  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 ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_BayesNetFragment_Sl_double_Sg__minimalCondSet__SWIG_0((gum::BayesNetFragment< double > const *)arg1,SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_BayesNetFragment_Sl_double_Sg__minimalCondSet__SWIG_1((gum::BayesNetFragment< double > const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfStr *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 = (PyAgrumSetOfStr *)gum_BayesNetFragment_Sl_double_Sg__names((gum::BayesNetFragment< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  gum::NodeGraphPart *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 = (gum::NodeGraphPart *) &gum_BayesNetFragment_Sl_double_Sg__nodes((gum::BayesNetFragment< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*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] ;
  PyAgrumSetOfArc *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 = (PyAgrumSetOfArc *)gum_BayesNetFragment_Sl_double_Sg__arcs((gum::BayesNetFragment< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_BayesNetFragment_Sl_double_Sg__parents((gum::BayesNetFragment< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_BayesNetFragment_Sl_double_Sg__children((gum::BayesNetFragment< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_BayesNetFragment_Sl_double_Sg__family((gum::BayesNetFragment< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_BayesNetFragment_Sl_double_Sg__descendants((gum::BayesNetFragment< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_BayesNetFragment_Sl_double_Sg__ancestors((gum::BayesNetFragment< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs3 ;
  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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs2 ;
  std::vector< std::string > _tmp_vs3 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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 );
  return resultobj;
fail:
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_LazyPropagation_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_LazyPropagation_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = (PyAgrumSetOfInt *)gum_LazyPropagation_Sl_double_Sg__targets((gum::LazyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    return _wrap_LazyPropagation_evidenceJointImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[1]) && !PyUnicode_Check(argv[1])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[1]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[1], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    if (!_v) goto check_2;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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] ;
  PyAgrumListOfSetOfInt *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 = (PyAgrumListOfSetOfInt *)gum_LazyPropagation_Sl_double_Sg__jointTargets((gum::LazyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs3 ;
  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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs2 ;
  std::vector< std::string > _tmp_vs3 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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 );
  return resultobj;
fail:
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_ShaferShenoyInference_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_ShaferShenoyInference_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = (PyAgrumSetOfInt *)gum_ShaferShenoyInference_Sl_double_Sg__targets((gum::ShaferShenoyInference< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyInference_evidenceJointImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[1]) && !PyUnicode_Check(argv[1])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[1]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[1], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    if (!_v) goto check_2;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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] ;
  PyAgrumListOfSetOfInt *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 = (PyAgrumListOfSetOfInt *)gum_ShaferShenoyInference_Sl_double_Sg__jointTargets((gum::ShaferShenoyInference< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs3 ;
  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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_VariableElimination_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_VariableElimination_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      result = (PyAgrumSetOfInt *)gum_VariableElimination_Sl_double_Sg__targets((gum::VariableElimination< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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] ;
  PyAgrumListOfSetOfInt *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 = (PyAgrumListOfSetOfInt *)gum_VariableElimination_Sl_double_Sg__jointTargets((gum::VariableElimination< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs3 ;
  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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_GibbsSampling_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_GibbsSampling_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = (PyAgrumSetOfInt *)gum_GibbsSampling_Sl_double_Sg__targets((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs3 ;
  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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_ImportanceSampling_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_ImportanceSampling_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = (PyAgrumSetOfInt *)gum_ImportanceSampling_Sl_double_Sg__targets((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs3 ;
  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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_WeightedSampling_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_WeightedSampling_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = (PyAgrumSetOfInt *)gum_WeightedSampling_Sl_double_Sg__targets((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs3 ;
  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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_MonteCarloSampling_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_MonteCarloSampling_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (PyAgrumSetOfInt *)gum_MonteCarloSampling_Sl_double_Sg__targets((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs3 ;
  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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = (PyAgrumSetOfInt *)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__targets((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs3 ;
  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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = (PyAgrumSetOfInt *)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__targets((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs3 ;
  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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = (PyAgrumSetOfInt *)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__targets((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs3 ;
  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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = (PyAgrumSetOfInt *)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__targets((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs3 ;
  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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_LoopyBeliefPropagation_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_LoopyBeliefPropagation_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = (PyAgrumSetOfInt *)gum_LoopyBeliefPropagation_Sl_double_Sg__targets((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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] ;
  PyAgrumDict *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 = (PyAgrumDict *)gum_ExactBNdistance_Sl_double_Sg__compute(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumDict *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 = (PyAgrumDict *)gum_GibbsBNdistance_Sl_double_Sg__compute(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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_MCBNDistance__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::MCBNDistance< 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_MCBNDistance" "', argument " "1"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MCBNDistance" "', 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_MCBNDistance" "', argument " "2"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MCBNDistance" "', argument " "2"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::IBayesNet< double > * >(argp2);
  {
    try {
      result = (gum::MCBNDistance< double > *)new gum::MCBNDistance< 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__MCBNDistanceT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MCBNDistance__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::MCBNDistance< 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_MCBNDistance" "', argument " "1"" of type '" "gum::BNdistance< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MCBNDistance" "', argument " "1"" of type '" "gum::BNdistance< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::BNdistance< double > * >(argp1);
  {
    try {
      result = (gum::MCBNDistance< double > *)new gum::MCBNDistance< double >((gum::BNdistance< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MCBNDistanceT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MCBNDistance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MCBNDistance", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_MCBNDistance__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_MCBNDistance__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_MCBNDistance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MCBNDistance< double >::MCBNDistance(gum::IBayesNet< double > const &,gum::IBayesNet< double > const &)\n"
    "    gum::MCBNDistance< double >::MCBNDistance(gum::BNdistance< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MCBNDistance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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__MCBNDistanceT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCBNDistance" "', argument " "1"" of type '" "gum::MCBNDistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


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


SWIGINTERN PyObject *_wrap_MCBNDistance_setEpsilon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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, "MCBNDistance_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_setEpsilon" "', argument " "1"" of type '" "gum::MCBNDistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MCBNDistance_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_MCBNDistance_Sl_double_Sg__setEpsilon(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MCBNDistance_setMinEpsilonRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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, "MCBNDistance_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_setMinEpsilonRate" "', argument " "1"" of type '" "gum::MCBNDistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MCBNDistance_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_MCBNDistance_Sl_double_Sg__setMinEpsilonRate(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MCBNDistance_setMaxIter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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, "MCBNDistance_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_setMaxIter" "', argument " "1"" of type '" "gum::MCBNDistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MCBNDistance_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_MCBNDistance_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_MCBNDistance_setMaxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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, "MCBNDistance_setMaxTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_setMaxTime" "', argument " "1"" of type '" "gum::MCBNDistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MCBNDistance_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_MCBNDistance_Sl_double_Sg__setMaxTime(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MCBNDistance_setPeriodSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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, "MCBNDistance_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_setPeriodSize" "', argument " "1"" of type '" "gum::MCBNDistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MCBNDistance_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_MCBNDistance_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_MCBNDistance_verbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_verbosity" "', argument " "1"" of type '" "gum::MCBNDistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  {
    try {
      result = (bool)gum_MCBNDistance_Sl_double_Sg__verbosity((gum::MCBNDistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MCBNDistance_epsilon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_epsilon" "', argument " "1"" of type '" "gum::MCBNDistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  {
    try {
      result = (double)gum_MCBNDistance_Sl_double_Sg__epsilon((gum::MCBNDistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MCBNDistance_minEpsilonRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_minEpsilonRate" "', argument " "1"" of type '" "gum::MCBNDistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  {
    try {
      result = (double)gum_MCBNDistance_Sl_double_Sg__minEpsilonRate((gum::MCBNDistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MCBNDistance_maxIter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_maxIter" "', argument " "1"" of type '" "gum::MCBNDistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  {
    try {
      result = gum_MCBNDistance_Sl_double_Sg__maxIter((gum::MCBNDistance< 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_MCBNDistance_maxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_maxTime" "', argument " "1"" of type '" "gum::MCBNDistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  {
    try {
      result = (double)gum_MCBNDistance_Sl_double_Sg__maxTime((gum::MCBNDistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MCBNDistance_periodSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_periodSize" "', argument " "1"" of type '" "gum::MCBNDistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  {
    try {
      result = gum_MCBNDistance_Sl_double_Sg__periodSize((gum::MCBNDistance< 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_MCBNDistance_nbrIterations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_nbrIterations" "', argument " "1"" of type '" "gum::MCBNDistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  {
    try {
      result = gum_MCBNDistance_Sl_double_Sg__nbrIterations((gum::MCBNDistance< 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_MCBNDistance_currentTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_currentTime" "', argument " "1"" of type '" "gum::MCBNDistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  {
    try {
      result = (double)gum_MCBNDistance_Sl_double_Sg__currentTime((gum::MCBNDistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MCBNDistance_messageApproximationScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_messageApproximationScheme" "', argument " "1"" of type '" "gum::MCBNDistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  {
    try {
      result = gum_MCBNDistance_Sl_double_Sg__messageApproximationScheme((gum::MCBNDistance< 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_MCBNDistance_history(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance_history" "', argument " "1"" of type '" "gum::MCBNDistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_MCBNDistance_Sl_double_Sg__history((gum::MCBNDistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MCBNDistance__asIApproximationSchemeConfiguration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MCBNDistance< 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__MCBNDistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MCBNDistance__asIApproximationSchemeConfiguration" "', argument " "1"" of type '" "gum::MCBNDistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MCBNDistance< double > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration *) &gum_MCBNDistance_Sl_double_Sg___asIApproximationSchemeConfiguration((gum::MCBNDistance< 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 *MCBNDistance_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__MCBNDistanceT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCBNDistance_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_view arg2 ;
  bool arg3 ;
  bool arg4 ;
  std::string arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg2)),arg3,arg4,SWIG_STD_MOVE(*(&arg5)),arg6);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  bool arg3 ;
  bool arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg2)),arg3,arg4,SWIG_STD_MOVE(*(&arg5)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg2)),arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      ((gum::learning::BNDatabaseGenerator< double > const *)arg1)->toCSV(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,bool,bool,std::string,bool) const\n"
    "    gum::learning::BNDatabaseGenerator< double >::toCSV(std::string_view,bool,bool,std::string) const\n"
    "    gum::learning::BNDatabaseGenerator< double >::toCSV(std::string_view,bool,bool) const\n"
    "    gum::learning::BNDatabaseGenerator< double >::toCSV(std::string_view,bool) const\n"
    "    gum::learning::BNDatabaseGenerator< double >::toCSV(std::string_view) 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 ;
  std::vector< std::string > _tmp_vs2 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      (arg1)->setVarOrder((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->setVarOrderFromCSV(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->setVarOrderFromCSV(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,std::string_view)\n"
    "    gum::learning::BNDatabaseGenerator< double >::setVarOrderFromCSV(std::string_view)\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] ;
  SwigValueWrapper< 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;
    }
  }
  {
    std::vector<std::string> _v = std::move(result);
    Py_ssize_t _n = static_cast<Py_ssize_t>(_v.size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyUnicode_FromString(_v[_i].c_str()));
  }
  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] ;
  PyAgrumTupleOfInt *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 = (PyAgrumTupleOfInt *)gum_learning_BNDatabaseGenerator_Sl_double_Sg__varOrder((gum::learning::BNDatabaseGenerator< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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_view arg1 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  bool arg3 ;
  PyObject *bytes1 = NULL ;
  std::vector< std::string > _tmp_vs2 ;
  bool val3 ;
  int ecode3 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  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 >(SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BNLearner__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  PyObject *bytes1 = NULL ;
  std::vector< std::string > _tmp_vs2 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *)new gum::learning::BNLearner< double >(SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BNLearner__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *)new gum::learning::BNLearner< double >(SWIG_STD_MOVE(*(&arg1)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  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_view arg1 ;
  gum::BayesNet< double > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  PyObject *bytes1 = NULL ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< std::string > _tmp_vs3 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *)new gum::learning::BNLearner< double >(SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BNLearner__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  gum::BayesNet< double > *arg2 = 0 ;
  PyObject *bytes1 = NULL ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  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 >(SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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_view,std::vector< std::string,std::allocator< std::string > > const &,bool const)\n"
    "    gum::learning::BNLearner< double >::BNLearner(std::string_view,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::learning::BNLearner< double >::BNLearner(std::string_view)\n"
    "    gum::learning::BNLearner< double >::BNLearner(gum::learning::DatabaseTable const &)\n"
    "    gum::learning::BNLearner< double >::BNLearner(std::string_view,gum::BayesNet< double > const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::learning::BNLearner< double >::BNLearner(std::string_view,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_view arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useDirichletPrior(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,double)\n"
    "    gum::learning::BNLearner< double >::useDirichletPrior(std::string_view)\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_useExtendedGreedyHillClimbing(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_useExtendedGreedyHillClimbing" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useExtendedGreedyHillClimbing();
    } 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_useGreedyThickThinning(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_useGreedyThickThinning" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useGreedyThickThinning();
    } 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_setGreedyThickThinningReversals(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_setGreedyThickThinningReversals", 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_setGreedyThickThinningReversals" "', 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_setGreedyThickThinningReversals" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setGreedyThickThinningReversals(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_greedyThickThinningReversals(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_greedyThickThinningReversals" "', 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)->greedyThickThinningReversals();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  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_usePC(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_usePC" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->usePC();
    } 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_useFCI(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_useFCI" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useFCI();
    } 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_useFCIChi2Test(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_useFCIChi2Test" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useFCIChi2Test();
    } 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_useFCIG2Test(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_useFCIG2Test" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useFCIG2Test();
    } 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_setFCIAlpha(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_setFCIAlpha", 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_setFCIAlpha" "', 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_setFCIAlpha" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setFCIAlpha(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_setFCIMaxPathLength(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_setFCIMaxPathLength", 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_setFCIMaxPathLength" "', 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_setFCIMaxPathLength" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setFCIMaxPathLength(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_setFCIExhaustiveSepSet(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_setFCIExhaustiveSepSet", 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_setFCIExhaustiveSepSet" "', 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_setFCIExhaustiveSepSet" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setFCIExhaustiveSepSet(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_fciExhaustiveSepSet(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_fciExhaustiveSepSet" "', 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)->fciExhaustiveSepSet();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useChi2Test(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_useChi2Test" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useChi2Test();
    } 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_useG2Test(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_useG2Test" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->useG2Test();
    } 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_setPCAlpha(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_setPCAlpha", 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_setPCAlpha" "', 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_setPCAlpha" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setPCAlpha(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_setPCStable(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_setPCStable", 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_setPCStable" "', 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_setPCStable" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setPCStable(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_setPCMaxCondSetSize(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_setPCMaxCondSetSize", 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_setPCMaxCondSetSize" "', 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_setPCMaxCondSetSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setPCMaxCondSetSize(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_setPCUnshieldedColliderSorted(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_setPCUnshieldedColliderSorted", 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_setPCUnshieldedColliderSorted" "', 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_setPCUnshieldedColliderSorted" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setPCUnshieldedColliderSorted(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_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_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_setSliceOrder" "', argument " "2"" of type '" "std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_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_setTotalOrder__SWIG_0(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 ;
  std::vector< std::string > _tmp_vs2 ;
  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_setTotalOrder" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setTotalOrder((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_setTotalOrder__SWIG_1(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_setTotalOrder" "', 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_setTotalOrder" "', argument " "2"" of type '" "gum::Sequence< gum::NodeId > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "BNLearner_setTotalOrder" "', argument " "2"" of type '" "gum::Sequence< gum::NodeId > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Sequence< gum::NodeId > * >(argp2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->setTotalOrder((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_setTotalOrder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_setTotalOrder", 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_setTotalOrder__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_BNLearner_setTotalOrder__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_setTotalOrder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::setTotalOrder(std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::learning::BNLearner< double >::setTotalOrder(gum::Sequence< gum::NodeId > const &)\n");
  return 0;
}


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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view)\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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view)\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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view)\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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view)\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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view)\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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_allowArcAdditions(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_allowArcAdditions", 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_allowArcAdditions" "', 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_allowArcAdditions" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->allowArcAdditions(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_allowArcDeletions(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_allowArcDeletions", 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_allowArcDeletions" "', 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_allowArcDeletions" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->allowArcDeletions(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_allowArcReversals(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_allowArcReversals", 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_allowArcReversals" "', 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_allowArcReversals" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->allowArcReversals(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_allowArcTriangleDeletions(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_allowArcTriangleDeletions", 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_allowArcTriangleDeletions" "', 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_allowArcTriangleDeletions" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::learning::BNLearner< double > *) &(arg1)->allowArcTriangleDeletions(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_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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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_learnPAG(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::PAG 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_learnPAG" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__learnPAG(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::PAG(result)), SWIGTYPE_p_gum__PAG, 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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyUnicode_FromString((*result)[_i].c_str()));
  }
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__idFromName((gum::learning::BNLearner< double > const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  std::vector< std::string > _tmp_vs3 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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));
  return resultobj;
fail:
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    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));
  return resultobj;
fail:
  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_view arg2 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  std::vector< std::string > _tmp_vs3 ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__score__SWIG_2(arg1,SWIG_STD_MOVE(*(&arg2)),(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__score__SWIG_3(arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::learning::BNLearner< double >::score(std::string_view)\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_view arg2 ;
  std::string_view arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  std::vector< std::string > _tmp_vs4 ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[3]) || PyUnicode_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[3]);
    _tmp_vs4.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[3], _i);
      if (!_item) SWIG_fail;
      _tmp_vs4.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg4 = &_tmp_vs4;
  }
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__mutualInformation__SWIG_2(arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__mutualInformation__SWIG_3(arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::learning::BNLearner< double >::mutualInformation(std::string_view,std::string_view)\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_view arg2 ;
  std::string_view arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  std::vector< std::string > _tmp_vs4 ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[3]) || PyUnicode_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[3]);
    _tmp_vs4.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[3], _i);
      if (!_item) SWIG_fail;
      _tmp_vs4.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg4 = &_tmp_vs4;
  }
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__correctedMutualInformation__SWIG_2(arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__correctedMutualInformation__SWIG_3(arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::learning::BNLearner< double >::correctedMutualInformation(std::string_view,std::string_view)\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 ;
  SwigValueWrapper< 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;
    }
  }
  {
    std::vector<double> _v = std::move(result);
    Py_ssize_t _n = static_cast<Py_ssize_t>(_v.size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble(_v[_i]));
  }
  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 ;
  std::vector< std::string > _tmp_vs2 ;
  SwigValueWrapper< 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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    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;
    }
  }
  {
    std::vector<double> _v = std::move(result);
    Py_ssize_t _n = static_cast<Py_ssize_t>(_v.size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble(_v[_i]));
  }
  return resultobj;
fail:
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__domainSize__SWIG_1((gum::learning::BNLearner< double > const *)arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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 ;
  std::vector< std::string > _tmp_vs4 ;
  PyAgrumTupleFF *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;
  }
  {
    if (!PySequence_Check(swig_obj[3]) || PyUnicode_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[3]);
    _tmp_vs4.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[3], _i);
      if (!_item) SWIG_fail;
      _tmp_vs4.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg4 = &_tmp_vs4;
  }
  {
    try {
      result = (PyAgrumTupleFF *)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 (!resultobj) SWIG_fail;
  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__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 ;
  PyAgrumTupleFF *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 = (PyAgrumTupleFF *)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 (!resultobj) SWIG_fail;
  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 ;
  std::vector< std::string > _tmp_vs4 ;
  PyAgrumTupleFF *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;
  }
  {
    if (!PySequence_Check(swig_obj[3]) || PyUnicode_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[3]);
    _tmp_vs4.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[3], _i);
      if (!_item) SWIG_fail;
      _tmp_vs4.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg4 = &_tmp_vs4;
  }
  {
    try {
      result = (PyAgrumTupleFF *)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 (!resultobj) SWIG_fail;
  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__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 ;
  PyAgrumTupleFF *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 = (PyAgrumTupleFF *)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 (!resultobj) SWIG_fail;
  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_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) 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] ;
  PyAgrumListOfArc *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 = (PyAgrumListOfArc *)gum_learning_BNLearner_Sl_double_Sg__latentVariables(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumDictState *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 = (PyAgrumDictState *)gum_learning_BNLearner_Sl_double_Sg__state(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  gum::credal::CredalNet< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::credal::CredalNet< double > *)new gum::credal::CredalNet< double >(SWIG_STD_MOVE(*(&arg1)),SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__credal__CredalNetT_double_t, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CredalNet__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  gum::credal::CredalNet< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::credal::CredalNet< double > *)new gum::credal::CredalNet< double >(SWIG_STD_MOVE(*(&arg1)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__credal__CredalNetT_double_t, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  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_view,std::string_view)\n"
    "    gum::credal::CredalNet< double >::CredalNet(std::string_view)\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_view arg2 ;
  gum::Size *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg2)),(gum::Size const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CredalNet_setCPTs" "', argument " "3"" of type '" "std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_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 ;
  gum::Size temp3 ;
  size_t val3 ;
  int ecode3 = 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;
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CredalNet_setCPT" "', argument " "3"" of type '" "gum::Size""'");
  } 
  temp3 = static_cast< gum::Size >(val3);
  arg3 = &temp3;
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CredalNet_setCPT" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_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,(gum::Size const &)*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 = 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_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_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CredalNet_setCPT" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_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;
    {
      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_setCPT__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_CredalNet_setCPT__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_setCPT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::credal::CredalNet< double >::setCPT(gum::NodeId const &,gum::Size const &,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 ;
  std::vector< double > _tmp_vd3 ;
  std::vector< double > _tmp_vd4 ;
  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;
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    if (!PySequence_Check(swig_obj[3]) || PyUnicode_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[3]);
    _tmp_vd4.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[3], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd4.push_back(_val);
    }
    arg4 = &_tmp_vd4;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd4 ;
  std::vector< double > _tmp_vd5 ;
  
  (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;
  {
    if (!PySequence_Check(swig_obj[3]) || PyUnicode_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[3]);
    _tmp_vd4.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[3], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd4.push_back(_val);
    }
    arg4 = &_tmp_vd4;
  }
  {
    if (!PySequence_Check(swig_obj[4]) || PyUnicode_Check(swig_obj[4])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[4]);
    _tmp_vd5.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[4], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd5.push_back(_val);
    }
    arg5 = &_tmp_vd5;
  }
  {
    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();
  return resultobj;
fail:
  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 = 0 ;
  int res3 = 0 ;
  std::vector< double > _tmp_vd4 ;
  std::vector< double > _tmp_vd5 ;
  
  (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;
    }
  }
  {
    if (!PySequence_Check(swig_obj[3]) || PyUnicode_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[3]);
    _tmp_vd4.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[3], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd4.push_back(_val);
    }
    arg4 = &_tmp_vd4;
  }
  {
    if (!PySequence_Check(swig_obj[4]) || PyUnicode_Check(swig_obj[4])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[4]);
    _tmp_vd5.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[4], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd5.push_back(_val);
    }
    arg5 = &_tmp_vd5;
  }
  {
    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();
  return resultobj;
fail:
  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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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 > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->saveBNsMinMax(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_credalNet_srcCpt(PyObject *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_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_currentNodeType(PyObject *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_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_get_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_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet___repr__(PyObject *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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->insertEvidenceFile(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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_insertEvidenceFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->insertEvidenceFile(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->saveInference(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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;
    }
  }
  {
    Py_ssize_t _n = static_cast<Py_ssize_t>(result->size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyFloat_FromDouble((*result)[_i]));
  }
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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_view arg1 ;
  gum::Size arg2 ;
  PyObject *bytes1 = NULL ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::InfluenceDiagram< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_fastPrototype__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  gum::InfluenceDiagram< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = gum::InfluenceDiagram< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype(SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_fastPrototype__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  gum::InfluenceDiagram< double > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      result = gum::InfluenceDiagram< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype(SWIG_STD_MOVE(*(&arg1)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::InfluenceDiagram< double >(result)), SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  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_view,gum::Size)\n"
    "    gum::InfluenceDiagram< double >::fastPrototype(std::string_view,std::string_view)\n"
    "    gum::InfluenceDiagram< double >::fastPrototype(std::string_view)\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__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< gum::InfluenceDiagram< double > > rvrdeleter1 ;
  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, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InfluenceDiagram" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "gum::InfluenceDiagram< double > &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InfluenceDiagram" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InfluenceDiagram" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > &&""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    try {
      result = (gum::InfluenceDiagram< double > *)new gum::InfluenceDiagram< double >((gum::InfluenceDiagram< double > &&)*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) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_InfluenceDiagram__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_InfluenceDiagram__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_InfluenceDiagram'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::InfluenceDiagram()\n"
    "    gum::InfluenceDiagram< double >::InfluenceDiagram(gum::InfluenceDiagram< double > const &)\n"
    "    gum::InfluenceDiagram< double >::InfluenceDiagram(gum::InfluenceDiagram< double > &&)\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_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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (arg1)->add(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,unsigned int)\n"
    "    gum::InfluenceDiagram< double >::add(std::string_view)\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_view arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (arg1)->addChanceNode(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,unsigned int)\n"
    "    gum::InfluenceDiagram< double >::addChanceNode(std::string_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (arg1)->addUtilityNode(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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_view arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (arg1)->addDecisionNode(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,unsigned int)\n"
    "    gum::InfluenceDiagram< double >::addDecisionNode(std::string_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->erase(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *bytes3 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->changeVariableName(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->changeVariableName(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view)\n"
    "    gum::InfluenceDiagram< double >::changeVariableName(std::string_view,std::string_view)\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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->addArc(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view)\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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->eraseArc(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view)\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;
  
  (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::InfluenceDiagram< double > const *)arg1)->getDecisionGraph();
    } 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_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 = PyAgrumHelper::PyListFromNodeVect(result);
  }
  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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    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));
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view,std::string_view) 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_idFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::InfluenceDiagram< double > const *)arg1)->idFromName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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 ;
  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(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_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram_variable__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_variable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::variable(std::string_view) const\n"
    "    gum::InfluenceDiagram< double >::variable(gum::NodeId) 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_variableFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::InfluenceDiagram< double > const *)arg1)->variableFromName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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] ;
  PyAgrumSetOfStr *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 = (PyAgrumSetOfStr *)gum_InfluenceDiagram_Sl_double_Sg__names((gum::InfluenceDiagram< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  gum::NodeGraphPart *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 = (gum::NodeGraphPart *) &gum_InfluenceDiagram_Sl_double_Sg__nodes((gum::InfluenceDiagram< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*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] ;
  PyAgrumSetOfArc *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 = (PyAgrumSetOfArc *)gum_InfluenceDiagram_Sl_double_Sg__arcs((gum::InfluenceDiagram< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_InfluenceDiagram_Sl_double_Sg__parents((gum::InfluenceDiagram< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_InfluenceDiagram_Sl_double_Sg__children((gum::InfluenceDiagram< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_InfluenceDiagram_Sl_double_Sg__family((gum::InfluenceDiagram< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_InfluenceDiagram_Sl_double_Sg__descendants((gum::InfluenceDiagram< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_InfluenceDiagram_Sl_double_Sg__ancestors((gum::InfluenceDiagram< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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_loadGUM__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< 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__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_loadGUM" "', 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_loadGUM" "', 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 '" "InfluenceDiagram_loadGUM" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      gum_InfluenceDiagram_Sl_double_Sg__loadGUM__SWIG_0(arg1,SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_loadGUM__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 ;
  
  (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_loadGUM" "', 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_loadGUM" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_InfluenceDiagram_Sl_double_Sg__loadGUM__SWIG_0(arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_loadGUM(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_loadGUM", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram_loadGUM__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_InfluenceDiagram_loadGUM__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_loadGUM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::loadGUM(std::string,bool)\n"
    "    gum::InfluenceDiagram< double >::loadGUM(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram__saveGUM__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (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__saveGUM" "', 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__saveGUM" "', 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 '" "InfluenceDiagram__saveGUM" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InfluenceDiagram__saveGUM" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      gum_InfluenceDiagram_Sl_double_Sg__saveGUM__SWIG_0(arg1,SWIG_STD_MOVE(*(&arg2)),arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram__saveGUM__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< 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__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram__saveGUM" "', 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__saveGUM" "', 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 '" "InfluenceDiagram__saveGUM" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      gum_InfluenceDiagram_Sl_double_Sg__saveGUM__SWIG_0(arg1,SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram__saveGUM__SWIG_2(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 ;
  
  (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__saveGUM" "', 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__saveGUM" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_InfluenceDiagram_Sl_double_Sg__saveGUM__SWIG_0(arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram__saveGUM(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram__saveGUM", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram__saveGUM__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_InfluenceDiagram__saveGUM__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_InfluenceDiagram__saveGUM__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__saveGUM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::saveGUM(std::string,bool,int)\n"
    "    gum::InfluenceDiagram< double >::saveGUM(std::string,bool)\n"
    "    gum::InfluenceDiagram< double >::saveGUM(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram__saveGUMstring__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string 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__saveGUMstring" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagram__saveGUMstring" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = gum_InfluenceDiagram_Sl_double_Sg__saveGUMstring__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram__saveGUMstring__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 ;
  std::string result;
  
  (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 '" "InfluenceDiagram__saveGUMstring" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = gum_InfluenceDiagram_Sl_double_Sg__saveGUMstring__SWIG_0(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram__saveGUMstring(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram__saveGUMstring", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_InfluenceDiagram__saveGUMstring__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_InfluenceDiagram__saveGUMstring__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__saveGUMstring'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::saveGUMstring(int)\n"
    "    gum::InfluenceDiagram< double >::saveGUMstring()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_loadGUMstring(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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_loadGUMstring", 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_loadGUMstring" "', 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_loadGUMstring" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InfluenceDiagram_loadGUMstring" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_InfluenceDiagram_Sl_double_Sg__loadGUMstring(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_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 ;
  std::vector< std::string > _tmp_vs2 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      (arg1)->addNoForgettingAssumption((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (arg1)->meanVar(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj=PyAgrumHelper::PyDictFromPairMeanVar(result) ;
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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) {
    int _v = 0;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[1]);
#else
      _v = PyUnicode_Check(argv[1]) || PyBytes_Check(argv[1]);
#endif
    }
    if (!_v) goto check_3;
    return _wrap_ShaferShenoyLIMIDInference_posterior__SWIG_1(self, argc, argv);
  }
check_3:
  
  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_view)\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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_ShaferShenoyLIMIDInference_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_ShaferShenoyLIMIDInference_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumDictSF *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 = (PyAgrumDictSF *)gum_ShaferShenoyLIMIDInference_Sl_double_Sg__MEU__SWIG_1(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumDictSF *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 = (PyAgrumDictSF *)gum_ShaferShenoyLIMIDInference_Sl_double_Sg__meanVar__SWIG_2(arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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_view)\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 ;
  gum::NodeSet _ns_temp2 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    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 = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::NodeSet *) &((gum::IMarkovRandomField< double > const *)arg1)->smallestFactorFromNode(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view) 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___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_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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    try {
      result = ((gum::IMarkovRandomField< double > const *)arg1)->minimalCondSet(SWIG_STD_MOVE(*(&arg2)),(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  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 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    try {
      result = ((gum::IMarkovRandomField< double > const *)arg1)->minimalCondSet((gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  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] ;
  PyAgrumSetOfStr *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 = (PyAgrumSetOfStr *)gum_IMarkovRandomField_Sl_double_Sg__names((gum::IMarkovRandomField< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  gum::NodeGraphPart *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 = (gum::NodeGraphPart *) &gum_IMarkovRandomField_Sl_double_Sg__nodes((gum::IMarkovRandomField< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_IMarkovRandomField_Sl_double_Sg__neighbours((gum::IMarkovRandomField< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfEdge *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 = (PyAgrumSetOfEdge *)gum_IMarkovRandomField_Sl_double_Sg__edges((gum::IMarkovRandomField< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_IMarkovRandomField_Sl_double_Sg__minimalCondSet__SWIG_2((gum::IMarkovRandomField< double > const *)arg1,SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_IMarkovRandomField_Sl_double_Sg__minimalCondSet__SWIG_3((gum::IMarkovRandomField< double > const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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_view arg1 ;
  gum::Size arg2 ;
  PyObject *bytes1 = NULL ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::MarkovRandomField< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_fastPrototype__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  gum::MarkovRandomField< double > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = gum::MarkovRandomField< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype(SWIG_STD_MOVE(*(&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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_fastPrototype__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  gum::MarkovRandomField< double > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      result = gum::MarkovRandomField< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype(SWIG_STD_MOVE(*(&arg1)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::MarkovRandomField< double >(result)), SWIGTYPE_p_gum__MarkovRandomFieldT_double_t, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  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_view,gum::Size)\n"
    "    gum::MarkovRandomField< double >::fastPrototype(std::string_view,std::string_view)\n"
    "    gum::MarkovRandomField< double >::fastPrototype(std::string_view)\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_view arg1 ;
  PyObject *bytes1 = NULL ;
  gum::MarkovRandomField< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  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_view)\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 ;
  gum::NodeSet _ns_temp2 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs2 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    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 );
  return resultobj;
fail:
  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 = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  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_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_view arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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(SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (arg1)->add(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view,unsigned int)\n"
    "    gum::MarkovRandomField< double >::add(std::string_view)\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_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->erase(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_view)\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 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


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_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *bytes3 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->changeVariableName(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->changeVariableName(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  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_view)\n"
    "    gum::MarkovRandomField< double >::changeVariableName(std::string_view,std::string_view)\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_view arg3 ;
  std::string_view arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *bytes3 = NULL ;
  PyObject *bytes4 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[3]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[3]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[3])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[3], &len, &bytes4);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[3]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[3]);
    }
#endif
    arg4 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->changeVariableLabel(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),SWIG_STD_MOVE(*(&arg4)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes3);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  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_view arg2 ;
  std::string_view arg3 ;
  std::string_view arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  PyObject *bytes4 = NULL ;
  
  (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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[3]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[3]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[3])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[3], &len, &bytes4);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[3]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[3]);
    }
#endif
    arg4 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->changeVariableLabel(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),SWIG_STD_MOVE(*(&arg4)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  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_view,std::string_view)\n"
    "    gum::MarkovRandomField< double >::changeVariableLabel(std::string_view,std::string_view,std::string_view)\n");
  return 0;
}


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 ;
  std::vector< std::string > _tmp_vs2 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    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 );
  return resultobj;
fail:
  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 ;
  gum::NodeSet _ns_temp2 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    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 ;
  gum::NodeSet _ns_temp2 ;
  
  (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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs2 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    try {
      (arg1)->eraseFactor((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_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 ;
  gum::NodeSet _ns_temp2 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    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;
  
  (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::MarkovRandomField< double > const *)arg1)->graph();
    } 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_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_idFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::MarkovRandomField< double > const *)arg1)->idFromName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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_variable__SWIG_1(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(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_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovRandomField_variable__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_variable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::variable(std::string_view) const\n"
    "    gum::MarkovRandomField< double >::variable(gum::NodeId) 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_variableFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::MarkovRandomField< double > const *)arg1)->variableFromName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  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] ;
  PyAgrumSetOfStr *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 = (PyAgrumSetOfStr *)gum_MarkovRandomField_Sl_double_Sg__names((gum::MarkovRandomField< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  gum::NodeGraphPart *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 = (gum::NodeGraphPart *) &gum_MarkovRandomField_Sl_double_Sg__nodes((gum::MarkovRandomField< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_MarkovRandomField_Sl_double_Sg__neighbours((gum::MarkovRandomField< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfEdge *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 = (PyAgrumSetOfEdge *)gum_MarkovRandomField_Sl_double_Sg__edges((gum::MarkovRandomField< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_MarkovRandomField_Sl_double_Sg__minimalCondSet__SWIG_0((gum::MarkovRandomField< double > const *)arg1,SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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 ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_MarkovRandomField_Sl_double_Sg__minimalCondSet__SWIG_1((gum::MarkovRandomField< double > const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    return _wrap_MarkovRandomField_factor__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[1]) && !PyUnicode_Check(argv[1])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[1]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[1], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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_loadGUM__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< 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__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField_loadGUM" "', 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_loadGUM" "', 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 '" "MarkovRandomField_loadGUM" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      gum_MarkovRandomField_Sl_double_Sg__loadGUM__SWIG_0(arg1,SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_loadGUM__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 ;
  
  (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_loadGUM" "', 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_loadGUM" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_MarkovRandomField_Sl_double_Sg__loadGUM__SWIG_0(arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_loadGUM(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField_loadGUM", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovRandomField_loadGUM__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_MarkovRandomField_loadGUM__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_loadGUM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::loadGUM(std::string,bool)\n"
    "    gum::MarkovRandomField< double >::loadGUM(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField__saveGUM__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (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__saveGUM" "', 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__saveGUM" "', 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 '" "MarkovRandomField__saveGUM" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkovRandomField__saveGUM" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      gum_MarkovRandomField_Sl_double_Sg__saveGUM__SWIG_0(arg1,SWIG_STD_MOVE(*(&arg2)),arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField__saveGUM__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< 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__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField__saveGUM" "', 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__saveGUM" "', 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 '" "MarkovRandomField__saveGUM" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      gum_MarkovRandomField_Sl_double_Sg__saveGUM__SWIG_0(arg1,SWIG_STD_MOVE(*(&arg2)),arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField__saveGUM__SWIG_2(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 ;
  
  (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__saveGUM" "', 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__saveGUM" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_MarkovRandomField_Sl_double_Sg__saveGUM__SWIG_0(arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField__saveGUM(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField__saveGUM", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovRandomField__saveGUM__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_MarkovRandomField__saveGUM__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_MarkovRandomField__saveGUM__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__saveGUM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::saveGUM(std::string,bool,int)\n"
    "    gum::MarkovRandomField< double >::saveGUM(std::string,bool)\n"
    "    gum::MarkovRandomField< double >::saveGUM(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField__saveGUMstring__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< double > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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__saveGUMstring" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkovRandomField__saveGUMstring" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = gum_MarkovRandomField_Sl_double_Sg__saveGUMstring__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField__saveGUMstring__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MarkovRandomField< 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__MarkovRandomFieldT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovRandomField__saveGUMstring" "', argument " "1"" of type '" "gum::MarkovRandomField< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovRandomField< double > * >(argp1);
  {
    try {
      result = gum_MarkovRandomField_Sl_double_Sg__saveGUMstring__SWIG_0(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField__saveGUMstring(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovRandomField__saveGUMstring", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_MarkovRandomField__saveGUMstring__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_MarkovRandomField__saveGUMstring__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__saveGUMstring'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovRandomField< double >::saveGUMstring(int)\n"
    "    gum::MarkovRandomField< double >::saveGUMstring()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovRandomField_loadGUMstring(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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MarkovRandomField_loadGUMstring", 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_loadGUMstring" "', 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_loadGUMstring" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkovRandomField_loadGUMstring" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_MarkovRandomField_Sl_double_Sg__loadGUMstring(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_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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[1]) && !PyUnicode_Check(argv[1])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[1]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[1], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    return _wrap_MarkovRandomField_eraseFactor__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[1]) && !PyUnicode_Check(argv[1])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[1]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[1], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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);
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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();
  return resultobj;
fail:
  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 ;
  std::vector< double > _tmp_vd3 ;
  
  (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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of floats");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vd3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      double _val = PyFloat_AsDouble(_item);
      Py_DECREF(_item);
      if (_val == -1.0 && PyErr_Occurred()) SWIG_fail;
      _tmp_vd3.push_back(_val);
    }
    arg3 = &_tmp_vd3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
    {
      {
        _v = (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) ? 1 : 0;
      }
    }
    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 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs3 ;
  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;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  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 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  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);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    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 ;
  std::vector< std::string > _tmp_vs2 ;
  std::vector< std::string > _tmp_vs3 ;
  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);
  {
    if (!PySequence_Check(swig_obj[1]) || PyUnicode_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[1]);
    _tmp_vs2.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[1], _i);
      if (!_item) SWIG_fail;
      _tmp_vs2.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg2 = &_tmp_vs2;
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    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 );
  return resultobj;
fail:
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_ShaferShenoyMRFInference_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_ShaferShenoyMRFInference_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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] ;
  PyAgrumSetOfInt *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 = (PyAgrumSetOfInt *)gum_ShaferShenoyMRFInference_Sl_double_Sg__targets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    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;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    return _wrap_ShaferShenoyMRFInference_evidenceJointImpact__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[1]) && !PyUnicode_Check(argv[1])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[1]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[1], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    if (!_v) goto check_2;
    {
      {
        // Accept only sequences whose first element is a string.
        // This lets PyObject* %extend dispatchers handle int-element sequences.
        _v = 0;
        if (PySequence_Check(argv[2]) && !PyUnicode_Check(argv[2])) {
          Py_ssize_t _tc_sz = PySequence_Size(argv[2]);
          if (_tc_sz == 0) {
            _v = 1;  // empty sequence: accept
          } else {
            PyObject* _tc_first = PySequence_GetItem(argv[2], 0);
            if (_tc_first) {
              _v = PyUnicode_Check(_tc_first) ? 1 : 0;
              Py_DECREF(_tc_first);
            }
          }
        }
      }
    }
    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] ;
  PyAgrumListOfSetOfInt *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 = (PyAgrumListOfSetOfInt *)gum_ShaferShenoyMRFInference_Sl_double_Sg__jointTargets((gum::ShaferShenoyMRFInference< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  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);
}

SWIGINTERN PyObject *_wrap_DoorCriteria_satisfiesBackdoorCriterion(PyObject *self, PyObject *args) {
  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 ;
  gum::NodeSet _ns_temp4 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DoorCriteria_satisfiesBackdoorCriterion", 4, 4, 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 '" "DoorCriteria_satisfiesBackdoorCriterion" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_satisfiesBackdoorCriterion" "', 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 '" "DoorCriteria_satisfiesBackdoorCriterion" "', 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 '" "DoorCriteria_satisfiesBackdoorCriterion" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    try {
      result = (bool)gum::DoorCriteria::satisfiesBackdoorCriterion((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_enumerateBackdoorSets__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 ;
  std::size_t arg5 ;
  bool arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeSet _ns_temp4 ;
  size_t val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  SwigValueWrapper< std::vector< gum::Set< std::size_t >,std::allocator< gum::Set< std::size_t > > > > result;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) 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 '" "DoorCriteria_enumerateBackdoorSets" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_enumerateBackdoorSets" "', 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 '" "DoorCriteria_enumerateBackdoorSets" "', 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 '" "DoorCriteria_enumerateBackdoorSets" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoorCriteria_enumerateBackdoorSets" "', argument " "5"" of type '" "std::size_t""'");
  } 
  arg5 = static_cast< std::size_t >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DoorCriteria_enumerateBackdoorSets" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DoorCriteria_enumerateBackdoorSets" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = gum::DoorCriteria::enumerateBackdoorSets((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4,SWIG_STD_MOVE(*(&arg5)),arg6,arg7);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    using _VecT = std::vector< gum::NodeSet >;
    _VecT _vec = std::move(result);
    resultobj = PyList_New(static_cast< Py_ssize_t >(_vec.size()));
    Py_ssize_t _i = 0;
    for (const auto& _ns : _vec)
    PyList_SET_ITEM(resultobj, _i++, PyAgrumHelper::PySetFromNodeSet(_ns));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_enumerateBackdoorSets__SWIG_1(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 ;
  std::size_t arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeSet _ns_temp4 ;
  size_t val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  SwigValueWrapper< std::vector< gum::Set< std::size_t >,std::allocator< gum::Set< std::size_t > > > > result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) 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 '" "DoorCriteria_enumerateBackdoorSets" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_enumerateBackdoorSets" "', 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 '" "DoorCriteria_enumerateBackdoorSets" "', 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 '" "DoorCriteria_enumerateBackdoorSets" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoorCriteria_enumerateBackdoorSets" "', argument " "5"" of type '" "std::size_t""'");
  } 
  arg5 = static_cast< std::size_t >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DoorCriteria_enumerateBackdoorSets" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = gum::DoorCriteria::enumerateBackdoorSets((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4,SWIG_STD_MOVE(*(&arg5)),arg6);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    using _VecT = std::vector< gum::NodeSet >;
    _VecT _vec = std::move(result);
    resultobj = PyList_New(static_cast< Py_ssize_t >(_vec.size()));
    Py_ssize_t _i = 0;
    for (const auto& _ns : _vec)
    PyList_SET_ITEM(resultobj, _i++, PyAgrumHelper::PySetFromNodeSet(_ns));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_enumerateBackdoorSets__SWIG_2(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 ;
  std::size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeSet _ns_temp4 ;
  size_t val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< std::vector< gum::Set< std::size_t >,std::allocator< gum::Set< std::size_t > > > > result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) 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 '" "DoorCriteria_enumerateBackdoorSets" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_enumerateBackdoorSets" "', 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 '" "DoorCriteria_enumerateBackdoorSets" "', 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 '" "DoorCriteria_enumerateBackdoorSets" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoorCriteria_enumerateBackdoorSets" "', argument " "5"" of type '" "std::size_t""'");
  } 
  arg5 = static_cast< std::size_t >(val5);
  {
    try {
      result = gum::DoorCriteria::enumerateBackdoorSets((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4,SWIG_STD_MOVE(*(&arg5)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    using _VecT = std::vector< gum::NodeSet >;
    _VecT _vec = std::move(result);
    resultobj = PyList_New(static_cast< Py_ssize_t >(_vec.size()));
    Py_ssize_t _i = 0;
    for (const auto& _ns : _vec)
    PyList_SET_ITEM(resultobj, _i++, PyAgrumHelper::PySetFromNodeSet(_ns));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_enumerateBackdoorSets__SWIG_3(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 ;
  gum::NodeSet _ns_temp4 ;
  SwigValueWrapper< std::vector< gum::Set< std::size_t >,std::allocator< gum::Set< std::size_t > > > > 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 '" "DoorCriteria_enumerateBackdoorSets" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_enumerateBackdoorSets" "', 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 '" "DoorCriteria_enumerateBackdoorSets" "', 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 '" "DoorCriteria_enumerateBackdoorSets" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    try {
      result = gum::DoorCriteria::enumerateBackdoorSets((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    using _VecT = std::vector< gum::NodeSet >;
    _VecT _vec = std::move(result);
    resultobj = PyList_New(static_cast< Py_ssize_t >(_vec.size()));
    Py_ssize_t _i = 0;
    for (const auto& _ns : _vec)
    PyList_SET_ITEM(resultobj, _i++, PyAgrumHelper::PySetFromNodeSet(_ns));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_enumerateBackdoorSets__SWIG_4(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 ;
  SwigValueWrapper< std::vector< gum::Set< std::size_t >,std::allocator< 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 '" "DoorCriteria_enumerateBackdoorSets" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_enumerateBackdoorSets" "', 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 '" "DoorCriteria_enumerateBackdoorSets" "', 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 '" "DoorCriteria_enumerateBackdoorSets" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = gum::DoorCriteria::enumerateBackdoorSets((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    using _VecT = std::vector< gum::NodeSet >;
    _VecT _vec = std::move(result);
    resultobj = PyList_New(static_cast< Py_ssize_t >(_vec.size()));
    Py_ssize_t _i = 0;
    for (const auto& _ns : _vec)
    PyList_SET_ITEM(resultobj, _i++, PyAgrumHelper::PySetFromNodeSet(_ns));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_enumerateBackdoorSets__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< std::vector< gum::Set< std::size_t >,std::allocator< gum::Set< std::size_t > > > > 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 '" "DoorCriteria_enumerateBackdoorSets" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_enumerateBackdoorSets" "', 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 '" "DoorCriteria_enumerateBackdoorSets" "', 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 '" "DoorCriteria_enumerateBackdoorSets" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoorCriteria_enumerateBackdoorSets" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = gum::DoorCriteria::enumerateBackdoorSets((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    using _VecT = std::vector< gum::NodeSet >;
    _VecT _vec = std::move(result);
    resultobj = PyList_New(static_cast< Py_ssize_t >(_vec.size()));
    Py_ssize_t _i = 0;
    for (const auto& _ns : _vec)
    PyList_SET_ITEM(resultobj, _i++, PyAgrumHelper::PySetFromNodeSet(_ns));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_enumerateBackdoorSets(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoorCriteria_enumerateBackdoorSets", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_DoorCriteria_enumerateBackdoorSets__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      {
        if (PySet_Check(argv[3]) || PyFrozenSet_Check(argv[3])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[3]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_2;
    return _wrap_DoorCriteria_enumerateBackdoorSets__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_DoorCriteria_enumerateBackdoorSets__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_DoorCriteria_enumerateBackdoorSets__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_DoorCriteria_enumerateBackdoorSets__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_DoorCriteria_enumerateBackdoorSets__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 'DoorCriteria_enumerateBackdoorSets'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DoorCriteria::enumerateBackdoorSets(gum::DAG const &,gum::NodeId,gum::NodeId,gum::NodeSet const &,std::size_t,bool,bool)\n"
    "    gum::DoorCriteria::enumerateBackdoorSets(gum::DAG const &,gum::NodeId,gum::NodeId,gum::NodeSet const &,std::size_t,bool)\n"
    "    gum::DoorCriteria::enumerateBackdoorSets(gum::DAG const &,gum::NodeId,gum::NodeId,gum::NodeSet const &,std::size_t)\n"
    "    gum::DoorCriteria::enumerateBackdoorSets(gum::DAG const &,gum::NodeId,gum::NodeId,gum::NodeSet const &)\n"
    "    gum::DoorCriteria::enumerateBackdoorSets(gum::DAG const &,gum::NodeId,gum::NodeId)\n"
    "    gum::DoorCriteria::enumerateBackdoorSets(gum::DAG const &,gum::NodeId,gum::NodeId,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_firstBackdoor__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 ;
  std::size_t arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeSet _ns_temp4 ;
  size_t val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  std::optional< gum::NodeSet > result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) 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 '" "DoorCriteria_firstBackdoor" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_firstBackdoor" "', 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 '" "DoorCriteria_firstBackdoor" "', 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 '" "DoorCriteria_firstBackdoor" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoorCriteria_firstBackdoor" "', argument " "5"" of type '" "std::size_t""'");
  } 
  arg5 = static_cast< std::size_t >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DoorCriteria_firstBackdoor" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = gum::DoorCriteria::firstBackdoor((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4,SWIG_STD_MOVE(*(&arg5)),arg6);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PySetFromNodeSet((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_firstBackdoor__SWIG_1(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 ;
  std::size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeSet _ns_temp4 ;
  size_t val5 ;
  int ecode5 = 0 ;
  std::optional< gum::NodeSet > result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) 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 '" "DoorCriteria_firstBackdoor" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_firstBackdoor" "', 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 '" "DoorCriteria_firstBackdoor" "', 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 '" "DoorCriteria_firstBackdoor" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoorCriteria_firstBackdoor" "', argument " "5"" of type '" "std::size_t""'");
  } 
  arg5 = static_cast< std::size_t >(val5);
  {
    try {
      result = gum::DoorCriteria::firstBackdoor((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4,SWIG_STD_MOVE(*(&arg5)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PySetFromNodeSet((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_firstBackdoor__SWIG_2(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 ;
  gum::NodeSet _ns_temp4 ;
  std::optional< gum::NodeSet > 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 '" "DoorCriteria_firstBackdoor" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_firstBackdoor" "', 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 '" "DoorCriteria_firstBackdoor" "', 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 '" "DoorCriteria_firstBackdoor" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    try {
      result = gum::DoorCriteria::firstBackdoor((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PySetFromNodeSet((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_firstBackdoor__SWIG_3(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 ;
  std::optional< gum::NodeSet > 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 '" "DoorCriteria_firstBackdoor" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_firstBackdoor" "', 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 '" "DoorCriteria_firstBackdoor" "', 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 '" "DoorCriteria_firstBackdoor" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = gum::DoorCriteria::firstBackdoor((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PySetFromNodeSet((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_firstBackdoor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoorCriteria_firstBackdoor", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_DoorCriteria_firstBackdoor__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_DoorCriteria_firstBackdoor__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_DoorCriteria_firstBackdoor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_DoorCriteria_firstBackdoor__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 'DoorCriteria_firstBackdoor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DoorCriteria::firstBackdoor(gum::DAG const &,gum::NodeId,gum::NodeId,gum::NodeSet const &,std::size_t,bool)\n"
    "    gum::DoorCriteria::firstBackdoor(gum::DAG const &,gum::NodeId,gum::NodeId,gum::NodeSet const &,std::size_t)\n"
    "    gum::DoorCriteria::firstBackdoor(gum::DAG const &,gum::NodeId,gum::NodeId,gum::NodeSet const &)\n"
    "    gum::DoorCriteria::firstBackdoor(gum::DAG const &,gum::NodeId,gum::NodeId)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_satisfiesFrontdoorCriterion(PyObject *self, PyObject *args) {
  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 ;
  gum::NodeSet _ns_temp4 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DoorCriteria_satisfiesFrontdoorCriterion", 4, 4, 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 '" "DoorCriteria_satisfiesFrontdoorCriterion" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_satisfiesFrontdoorCriterion" "', 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 '" "DoorCriteria_satisfiesFrontdoorCriterion" "', 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 '" "DoorCriteria_satisfiesFrontdoorCriterion" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    try {
      result = (bool)gum::DoorCriteria::satisfiesFrontdoorCriterion((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_enumerateFrontdoorSets__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 ;
  std::size_t arg5 ;
  bool arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeSet _ns_temp4 ;
  size_t val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  SwigValueWrapper< std::vector< gum::Set< std::size_t >,std::allocator< gum::Set< std::size_t > > > > result;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) 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 '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_enumerateFrontdoorSets" "', 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 '" "DoorCriteria_enumerateFrontdoorSets" "', 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 '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "5"" of type '" "std::size_t""'");
  } 
  arg5 = static_cast< std::size_t >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = gum::DoorCriteria::enumerateFrontdoorSets((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4,SWIG_STD_MOVE(*(&arg5)),arg6,arg7);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    using _VecT = std::vector< gum::NodeSet >;
    _VecT _vec = std::move(result);
    resultobj = PyList_New(static_cast< Py_ssize_t >(_vec.size()));
    Py_ssize_t _i = 0;
    for (const auto& _ns : _vec)
    PyList_SET_ITEM(resultobj, _i++, PyAgrumHelper::PySetFromNodeSet(_ns));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_enumerateFrontdoorSets__SWIG_1(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 ;
  std::size_t arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeSet _ns_temp4 ;
  size_t val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  SwigValueWrapper< std::vector< gum::Set< std::size_t >,std::allocator< gum::Set< std::size_t > > > > result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) 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 '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_enumerateFrontdoorSets" "', 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 '" "DoorCriteria_enumerateFrontdoorSets" "', 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 '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "5"" of type '" "std::size_t""'");
  } 
  arg5 = static_cast< std::size_t >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = gum::DoorCriteria::enumerateFrontdoorSets((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4,SWIG_STD_MOVE(*(&arg5)),arg6);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    using _VecT = std::vector< gum::NodeSet >;
    _VecT _vec = std::move(result);
    resultobj = PyList_New(static_cast< Py_ssize_t >(_vec.size()));
    Py_ssize_t _i = 0;
    for (const auto& _ns : _vec)
    PyList_SET_ITEM(resultobj, _i++, PyAgrumHelper::PySetFromNodeSet(_ns));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_enumerateFrontdoorSets__SWIG_2(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 ;
  std::size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeSet _ns_temp4 ;
  size_t val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< std::vector< gum::Set< std::size_t >,std::allocator< gum::Set< std::size_t > > > > result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) 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 '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_enumerateFrontdoorSets" "', 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 '" "DoorCriteria_enumerateFrontdoorSets" "', 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 '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "5"" of type '" "std::size_t""'");
  } 
  arg5 = static_cast< std::size_t >(val5);
  {
    try {
      result = gum::DoorCriteria::enumerateFrontdoorSets((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4,SWIG_STD_MOVE(*(&arg5)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    using _VecT = std::vector< gum::NodeSet >;
    _VecT _vec = std::move(result);
    resultobj = PyList_New(static_cast< Py_ssize_t >(_vec.size()));
    Py_ssize_t _i = 0;
    for (const auto& _ns : _vec)
    PyList_SET_ITEM(resultobj, _i++, PyAgrumHelper::PySetFromNodeSet(_ns));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_enumerateFrontdoorSets__SWIG_3(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 ;
  gum::NodeSet _ns_temp4 ;
  SwigValueWrapper< std::vector< gum::Set< std::size_t >,std::allocator< gum::Set< std::size_t > > > > 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 '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_enumerateFrontdoorSets" "', 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 '" "DoorCriteria_enumerateFrontdoorSets" "', 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 '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    try {
      result = gum::DoorCriteria::enumerateFrontdoorSets((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    using _VecT = std::vector< gum::NodeSet >;
    _VecT _vec = std::move(result);
    resultobj = PyList_New(static_cast< Py_ssize_t >(_vec.size()));
    Py_ssize_t _i = 0;
    for (const auto& _ns : _vec)
    PyList_SET_ITEM(resultobj, _i++, PyAgrumHelper::PySetFromNodeSet(_ns));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_enumerateFrontdoorSets__SWIG_4(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 ;
  SwigValueWrapper< std::vector< gum::Set< std::size_t >,std::allocator< 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 '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_enumerateFrontdoorSets" "', 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 '" "DoorCriteria_enumerateFrontdoorSets" "', 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 '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = gum::DoorCriteria::enumerateFrontdoorSets((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    using _VecT = std::vector< gum::NodeSet >;
    _VecT _vec = std::move(result);
    resultobj = PyList_New(static_cast< Py_ssize_t >(_vec.size()));
    Py_ssize_t _i = 0;
    for (const auto& _ns : _vec)
    PyList_SET_ITEM(resultobj, _i++, PyAgrumHelper::PySetFromNodeSet(_ns));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_enumerateFrontdoorSets__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< std::vector< gum::Set< std::size_t >,std::allocator< gum::Set< std::size_t > > > > 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 '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_enumerateFrontdoorSets" "', 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 '" "DoorCriteria_enumerateFrontdoorSets" "', 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 '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoorCriteria_enumerateFrontdoorSets" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = gum::DoorCriteria::enumerateFrontdoorSets((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    using _VecT = std::vector< gum::NodeSet >;
    _VecT _vec = std::move(result);
    resultobj = PyList_New(static_cast< Py_ssize_t >(_vec.size()));
    Py_ssize_t _i = 0;
    for (const auto& _ns : _vec)
    PyList_SET_ITEM(resultobj, _i++, PyAgrumHelper::PySetFromNodeSet(_ns));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_enumerateFrontdoorSets(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoorCriteria_enumerateFrontdoorSets", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_DoorCriteria_enumerateFrontdoorSets__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      {
        if (PySet_Check(argv[3]) || PyFrozenSet_Check(argv[3])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[3]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_2;
    return _wrap_DoorCriteria_enumerateFrontdoorSets__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_DoorCriteria_enumerateFrontdoorSets__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_DoorCriteria_enumerateFrontdoorSets__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_DoorCriteria_enumerateFrontdoorSets__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_DoorCriteria_enumerateFrontdoorSets__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 'DoorCriteria_enumerateFrontdoorSets'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DoorCriteria::enumerateFrontdoorSets(gum::DAG const &,gum::NodeId,gum::NodeId,gum::NodeSet const &,std::size_t,bool,bool)\n"
    "    gum::DoorCriteria::enumerateFrontdoorSets(gum::DAG const &,gum::NodeId,gum::NodeId,gum::NodeSet const &,std::size_t,bool)\n"
    "    gum::DoorCriteria::enumerateFrontdoorSets(gum::DAG const &,gum::NodeId,gum::NodeId,gum::NodeSet const &,std::size_t)\n"
    "    gum::DoorCriteria::enumerateFrontdoorSets(gum::DAG const &,gum::NodeId,gum::NodeId,gum::NodeSet const &)\n"
    "    gum::DoorCriteria::enumerateFrontdoorSets(gum::DAG const &,gum::NodeId,gum::NodeId)\n"
    "    gum::DoorCriteria::enumerateFrontdoorSets(gum::DAG const &,gum::NodeId,gum::NodeId,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_firstFrontdoor__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 ;
  std::size_t arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeSet _ns_temp4 ;
  size_t val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  std::optional< gum::NodeSet > result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) 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 '" "DoorCriteria_firstFrontdoor" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_firstFrontdoor" "', 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 '" "DoorCriteria_firstFrontdoor" "', 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 '" "DoorCriteria_firstFrontdoor" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoorCriteria_firstFrontdoor" "', argument " "5"" of type '" "std::size_t""'");
  } 
  arg5 = static_cast< std::size_t >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DoorCriteria_firstFrontdoor" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = gum::DoorCriteria::firstFrontdoor((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4,SWIG_STD_MOVE(*(&arg5)),arg6);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PySetFromNodeSet((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_firstFrontdoor__SWIG_1(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 ;
  std::size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeSet _ns_temp4 ;
  size_t val5 ;
  int ecode5 = 0 ;
  std::optional< gum::NodeSet > result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) 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 '" "DoorCriteria_firstFrontdoor" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_firstFrontdoor" "', 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 '" "DoorCriteria_firstFrontdoor" "', 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 '" "DoorCriteria_firstFrontdoor" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoorCriteria_firstFrontdoor" "', argument " "5"" of type '" "std::size_t""'");
  } 
  arg5 = static_cast< std::size_t >(val5);
  {
    try {
      result = gum::DoorCriteria::firstFrontdoor((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4,SWIG_STD_MOVE(*(&arg5)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PySetFromNodeSet((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_firstFrontdoor__SWIG_2(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 ;
  gum::NodeSet _ns_temp4 ;
  std::optional< gum::NodeSet > 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 '" "DoorCriteria_firstFrontdoor" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_firstFrontdoor" "', 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 '" "DoorCriteria_firstFrontdoor" "', 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 '" "DoorCriteria_firstFrontdoor" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    try {
      result = gum::DoorCriteria::firstFrontdoor((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PySetFromNodeSet((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_firstFrontdoor__SWIG_3(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 ;
  std::optional< gum::NodeSet > 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 '" "DoorCriteria_firstFrontdoor" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_firstFrontdoor" "', 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 '" "DoorCriteria_firstFrontdoor" "', 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 '" "DoorCriteria_firstFrontdoor" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = gum::DoorCriteria::firstFrontdoor((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PySetFromNodeSet((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_firstFrontdoor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoorCriteria_firstFrontdoor", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_DoorCriteria_firstFrontdoor__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_DoorCriteria_firstFrontdoor__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_DoorCriteria_firstFrontdoor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_DoorCriteria_firstFrontdoor__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 'DoorCriteria_firstFrontdoor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DoorCriteria::firstFrontdoor(gum::DAG const &,gum::NodeId,gum::NodeId,gum::NodeSet const &,std::size_t,bool)\n"
    "    gum::DoorCriteria::firstFrontdoor(gum::DAG const &,gum::NodeId,gum::NodeId,gum::NodeSet const &,std::size_t)\n"
    "    gum::DoorCriteria::firstFrontdoor(gum::DAG const &,gum::NodeId,gum::NodeId,gum::NodeSet const &)\n"
    "    gum::DoorCriteria::firstFrontdoor(gum::DAG const &,gum::NodeId,gum::NodeId)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_existsUnblockedDirectedPath(PyObject *self, PyObject *args) {
  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 ;
  gum::NodeSet _ns_temp4 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DoorCriteria_existsUnblockedDirectedPath", 4, 4, 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 '" "DoorCriteria_existsUnblockedDirectedPath" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_existsUnblockedDirectedPath" "', 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 '" "DoorCriteria_existsUnblockedDirectedPath" "', 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 '" "DoorCriteria_existsUnblockedDirectedPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    try {
      result = (bool)gum::DoorCriteria::existsUnblockedDirectedPath((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_nodesOnDirectedPaths(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] ;
  std::optional< gum::NodeSet > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DoorCriteria_nodesOnDirectedPaths", 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 '" "DoorCriteria_nodesOnDirectedPaths" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_nodesOnDirectedPaths" "', 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 '" "DoorCriteria_nodesOnDirectedPaths" "', 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 '" "DoorCriteria_nodesOnDirectedPaths" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = gum::DoorCriteria::nodesOnDirectedPaths((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PySetFromNodeSet((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_backdoorReach(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] ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DoorCriteria_backdoorReach", 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 '" "DoorCriteria_backdoorReach" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_backdoorReach" "', 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 '" "DoorCriteria_backdoorReach" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum::DoorCriteria::backdoorReach((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoorCriteria_hasBackdoorPath(PyObject *self, PyObject *args) {
  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 ;
  gum::NodeSet _ns_temp4 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DoorCriteria_hasBackdoorPath", 4, 4, 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 '" "DoorCriteria_hasBackdoorPath" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoorCriteria_hasBackdoorPath" "', 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 '" "DoorCriteria_hasBackdoorPath" "', 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 '" "DoorCriteria_hasBackdoorPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    try {
      result = (bool)gum::DoorCriteria::hasBackdoorPath((gum::DAG const &)*arg1,SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)),(gum::Set< std::size_t > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoorCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DoorCriteria *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_DoorCriteria", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (gum::DoorCriteria *)new gum::DoorCriteria();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DoorCriteria, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DoorCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::DoorCriteria *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__DoorCriteria, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoorCriteria" "', argument " "1"" of type '" "gum::DoorCriteria *""'"); 
  }
  arg1 = reinterpret_cast< gum::DoorCriteria * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DoorCriteria_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__DoorCriteria, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

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

SWIGINTERN PyObject *_wrap__causalImpact__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::Set< std::string > *arg2 = 0 ;
  gum::Set< std::string > *arg3 = 0 ;
  gum::Set< std::string > *arg4 = 0 ;
  gum::HashTable< std::string,std::string > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Set< std::string > temp2 ;
  gum::Set< std::string > temp3 ;
  gum::Set< std::string > temp4 ;
  gum::HashTable< std::string,std::string > temp5 ;
  SwigValueWrapper< std::tuple< gum::CausalImpact< double >,gum::Tensor< double >,std::string > > result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_causalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "_causalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp2, swig_obj[1]);
    arg2 = &temp2;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp3, swig_obj[2]);
    arg3 = &temp3;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp4, swig_obj[3]);
    arg4 = &temp4;
  }
  {
    PyAgrumHelper::populateHashTableStrStrFromPyDict(temp5, swig_obj[4]);
    arg5 = &temp5;
  }
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR causalImpact< double >((gum::CausalModel< double > const &)*arg1,(gum::Set< std::string > const &)*arg2,(gum::Set< std::string > const &)*arg3,(gum::Set< std::string > const &)*arg4,(gum::HashTable< std::string,std::string > const &)*arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    // SwigValueWrapper<T> only exposes operator T&&(), not operator T&().
    // Move-construct a local tuple to get an lvalue we can work with.
    using _TupleT = std::tuple<gum::CausalImpact<double>, gum::Tensor<double>, std::string>;
    _TupleT _tup  = std::move(result);
    auto* _ci   = new gum::CausalImpact<double>(std::move(std::get<0>(_tup)));
    auto* _tens = new gum::Tensor<double>(std::move(std::get<1>(_tup)));
    resultobj = PyTuple_New(3);
    PyTuple_SET_ITEM(resultobj, 0,
      SWIG_NewPointerObj(_ci,   SWIGTYPE_p_gum__CausalImpactT_double_t, SWIG_POINTER_OWN));
    PyTuple_SET_ITEM(resultobj, 1,
      SWIG_NewPointerObj(_tens, SWIGTYPE_p_gum__TensorT_double_t,       SWIG_POINTER_OWN));
    PyTuple_SET_ITEM(resultobj, 2, PyUnicode_FromString(std::get<2>(_tup).c_str()));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__causalImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::Set< std::string > *arg2 = 0 ;
  gum::Set< std::string > *arg3 = 0 ;
  gum::Set< std::string > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Set< std::string > temp2 ;
  gum::Set< std::string > temp3 ;
  gum::Set< std::string > temp4 ;
  SwigValueWrapper< std::tuple< gum::CausalImpact< double >,gum::Tensor< double >,std::string > > result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_causalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "_causalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp2, swig_obj[1]);
    arg2 = &temp2;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp3, swig_obj[2]);
    arg3 = &temp3;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp4, swig_obj[3]);
    arg4 = &temp4;
  }
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR causalImpact< double >((gum::CausalModel< double > const &)*arg1,(gum::Set< std::string > const &)*arg2,(gum::Set< std::string > const &)*arg3,(gum::Set< std::string > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    // SwigValueWrapper<T> only exposes operator T&&(), not operator T&().
    // Move-construct a local tuple to get an lvalue we can work with.
    using _TupleT = std::tuple<gum::CausalImpact<double>, gum::Tensor<double>, std::string>;
    _TupleT _tup  = std::move(result);
    auto* _ci   = new gum::CausalImpact<double>(std::move(std::get<0>(_tup)));
    auto* _tens = new gum::Tensor<double>(std::move(std::get<1>(_tup)));
    resultobj = PyTuple_New(3);
    PyTuple_SET_ITEM(resultobj, 0,
      SWIG_NewPointerObj(_ci,   SWIGTYPE_p_gum__CausalImpactT_double_t, SWIG_POINTER_OWN));
    PyTuple_SET_ITEM(resultobj, 1,
      SWIG_NewPointerObj(_tens, SWIGTYPE_p_gum__TensorT_double_t,       SWIG_POINTER_OWN));
    PyTuple_SET_ITEM(resultobj, 2, PyUnicode_FromString(std::get<2>(_tup).c_str()));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__causalImpact__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::Set< std::string > *arg2 = 0 ;
  gum::Set< std::string > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Set< std::string > temp2 ;
  gum::Set< std::string > temp3 ;
  SwigValueWrapper< std::tuple< gum::CausalImpact< double >,gum::Tensor< double >,std::string > > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_causalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "_causalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp2, swig_obj[1]);
    arg2 = &temp2;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp3, swig_obj[2]);
    arg3 = &temp3;
  }
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR causalImpact< double >((gum::CausalModel< double > const &)*arg1,(gum::Set< std::string > const &)*arg2,(gum::Set< std::string > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    // SwigValueWrapper<T> only exposes operator T&&(), not operator T&().
    // Move-construct a local tuple to get an lvalue we can work with.
    using _TupleT = std::tuple<gum::CausalImpact<double>, gum::Tensor<double>, std::string>;
    _TupleT _tup  = std::move(result);
    auto* _ci   = new gum::CausalImpact<double>(std::move(std::get<0>(_tup)));
    auto* _tens = new gum::Tensor<double>(std::move(std::get<1>(_tup)));
    resultobj = PyTuple_New(3);
    PyTuple_SET_ITEM(resultobj, 0,
      SWIG_NewPointerObj(_ci,   SWIGTYPE_p_gum__CausalImpactT_double_t, SWIG_POINTER_OWN));
    PyTuple_SET_ITEM(resultobj, 1,
      SWIG_NewPointerObj(_tens, SWIGTYPE_p_gum__TensorT_double_t,       SWIG_POINTER_OWN));
    PyTuple_SET_ITEM(resultobj, 2, PyUnicode_FromString(std::get<2>(_tup).c_str()));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__causalImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "_causalImpact", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap__causalImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap__causalImpact__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap__causalImpact__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 '_causalImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::causalImpact< double >(gum::CausalModel< double > const &,gum::Set< std::string > const &,gum::Set< std::string > const &,gum::Set< std::string > const &,HashTable< std::string,std::string > const &)\n"
    "    gum::causalImpact< double >(gum::CausalModel< double > const &,gum::Set< std::string > const &,gum::Set< std::string > const &,gum::Set< std::string > const &)\n"
    "    gum::causalImpact< double >(gum::CausalModel< double > const &,gum::Set< std::string > const &,gum::Set< std::string > const &)\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_new_CausalModel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::LatentDescriptorVector *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  gum::CausalModel< double > *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 '" "new_CausalModel" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CausalModel" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_std__allocatorT_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CausalModel" "', argument " "2"" of type '" "gum::LatentDescriptorVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CausalModel" "', argument " "2"" of type '" "gum::LatentDescriptorVector const &""'"); 
  }
  arg2 = reinterpret_cast< gum::LatentDescriptorVector * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CausalModel" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (gum::CausalModel< double > *)new gum::CausalModel< double >((gum::BayesNet< double > const &)*arg1,(gum::LatentDescriptorVector const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CausalModelT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


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


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


SWIGINTERN PyObject *_wrap_delete_CausalModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalModel< 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__CausalModelT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CausalModel" "', argument " "1"" of type '" "gum::CausalModel< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_addLatentVariable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  std::string_view arg2 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  std::vector< std::string > _tmp_vs3 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_addLatentVariable" "', argument " "1"" of type '" "gum::CausalModel< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CausalModel_addLatentVariable" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      (arg1)->addLatentVariable(SWIG_STD_MOVE(*(&arg2)),(std::vector< std::string,std::allocator< std::string > > const &)*arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_addLatentVariable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  std::string_view arg2 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  std::vector< std::string > _tmp_vs3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_addLatentVariable" "', argument " "1"" of type '" "gum::CausalModel< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    if (!PySequence_Check(swig_obj[2]) || PyUnicode_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "expected a sequence of strings");
      SWIG_fail;
    }
    Py_ssize_t _n = PySequence_Size(swig_obj[2]);
    _tmp_vs3.reserve(static_cast<std::size_t>(_n));
    for (Py_ssize_t _i = 0; _i < _n; ++_i) {
      PyObject* _item = PySequence_GetItem(swig_obj[2], _i);
      if (!_item) SWIG_fail;
      _tmp_vs3.push_back(PyAgrumHelper::stringFromPyObject(_item));
      Py_DECREF(_item);
    }
    arg3 = &_tmp_vs3;
  }
  {
    try {
      (arg1)->addLatentVariable(SWIG_STD_MOVE(*(&arg2)),(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_addLatentVariable__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  std::string_view arg2 ;
  std::vector< gum::NodeId,std::allocator< gum::NodeId > > *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  void *argp3 = 0 ;
  int res3 = 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__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_addLatentVariable" "', argument " "1"" of type '" "gum::CausalModel< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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 '" "CausalModel_addLatentVariable" "', 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 '" "CausalModel_addLatentVariable" "', 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);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CausalModel_addLatentVariable" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      (arg1)->addLatentVariable(SWIG_STD_MOVE(*(&arg2)),(std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)*arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_addLatentVariable__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  std::string_view arg2 ;
  std::vector< gum::NodeId,std::allocator< gum::NodeId > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_addLatentVariable" "', argument " "1"" of type '" "gum::CausalModel< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  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 '" "CausalModel_addLatentVariable" "', 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 '" "CausalModel_addLatentVariable" "', 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 {
      (arg1)->addLatentVariable(SWIG_STD_MOVE(*(&arg2)),(std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_addLatentVariable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CausalModel_addLatentVariable", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      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_1;
    return _wrap_CausalModel_addLatentVariable__SWIG_3(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_CausalModel_addLatentVariable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      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;
    PyObject *retobj = _wrap_CausalModel_addLatentVariable__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_CausalModel_addLatentVariable__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 'CausalModel_addLatentVariable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalModel< double >::addLatentVariable(std::string_view,std::vector< std::string,std::allocator< std::string > > const &,bool)\n"
    "    gum::CausalModel< double >::addLatentVariable(std::string_view,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::CausalModel< double >::addLatentVariable(std::string_view,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &,bool)\n"
    "    gum::CausalModel< double >::addLatentVariable(std::string_view,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CausalModel_existsArc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< 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__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_existsArc" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CausalModel_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 '" "CausalModel_existsArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)((gum::CausalModel< double > 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_CausalModel_existsArc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_existsArc" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      result = (bool)((gum::CausalModel< double > const *)arg1)->existsArc(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_existsArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CausalModel_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_CausalModel_existsArc__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_CausalModel_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 'CausalModel_existsArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalModel< double >::existsArc(gum::NodeId,gum::NodeId) const\n"
    "    gum::CausalModel< double >::existsArc(std::string_view,std::string_view) const\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_CausalModel_assumeSpurious__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_assumeSpurious" "', argument " "1"" of type '" "gum::CausalModel< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->assumeSpurious(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_assumeSpurious(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CausalModel_assumeSpurious", 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_CausalModel_assumeSpurious__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_CausalModel_assumeSpurious__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 'CausalModel_assumeSpurious'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalModel< double >::assumeSpurious(gum::NodeId,gum::NodeId)\n"
    "    gum::CausalModel< double >::assumeSpurious(std::string_view,std::string_view)\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_CausalModel_assumeNonSpurious__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_assumeNonSpurious" "', argument " "1"" of type '" "gum::CausalModel< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      (arg1)->assumeNonSpurious(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_assumeNonSpurious(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CausalModel_assumeNonSpurious", 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_CausalModel_assumeNonSpurious__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_CausalModel_assumeNonSpurious__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 'CausalModel_assumeNonSpurious'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalModel< double >::assumeNonSpurious(gum::NodeId,gum::NodeId)\n"
    "    gum::CausalModel< double >::assumeNonSpurious(std::string_view,std::string_view)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CausalModel_isAssumedSpurious__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< 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__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_isAssumedSpurious" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CausalModel_isAssumedSpurious" "', 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 '" "CausalModel_isAssumedSpurious" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)((gum::CausalModel< double > const *)arg1)->isAssumedSpurious(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_CausalModel_isAssumedSpurious__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_isAssumedSpurious" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      result = (bool)((gum::CausalModel< double > const *)arg1)->isAssumedSpurious(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_isAssumedSpurious(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CausalModel_isAssumedSpurious", 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_CausalModel_isAssumedSpurious__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_CausalModel_isAssumedSpurious__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 'CausalModel_isAssumedSpurious'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalModel< double >::isAssumedSpurious(gum::NodeId,gum::NodeId) const\n"
    "    gum::CausalModel< double >::isAssumedSpurious(std::string_view,std::string_view) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CausalModel_backDoor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< 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 ;
  std::optional< gum::NodeSet > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_backDoor" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CausalModel_backDoor" "', 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 '" "CausalModel_backDoor" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->backDoor(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PySetFromNodeSet((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_backDoor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  std::optional< gum::NodeSet > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_backDoor" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->backDoor(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PySetFromNodeSet((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_backDoor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CausalModel_backDoor", 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_CausalModel_backDoor__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_CausalModel_backDoor__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 'CausalModel_backDoor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalModel< double >::backDoor(gum::NodeId,gum::NodeId) const\n"
    "    gum::CausalModel< double >::backDoor(std::string_view,std::string_view) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CausalModel_frontDoor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< 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 ;
  std::optional< gum::NodeSet > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_frontDoor" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CausalModel_frontDoor" "', 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 '" "CausalModel_frontDoor" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->frontDoor(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PySetFromNodeSet((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_frontDoor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  std::optional< gum::NodeSet > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_frontDoor" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->frontDoor(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    if ((&result)->has_value()) {
      resultobj = PyAgrumHelper::PySetFromNodeSet((&result)->value());
    } else {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_frontDoor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CausalModel_frontDoor", 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_CausalModel_frontDoor__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_CausalModel_frontDoor__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 'CausalModel_frontDoor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalModel< double >::frontDoor(gum::NodeId,gum::NodeId) const\n"
    "    gum::CausalModel< double >::frontDoor(std::string_view,std::string_view) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CausalModel_inducedCausalSubModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::CausalModel< double > *arg2 = 0 ;
  SwigValueWrapper< gum::Set< std::size_t > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SwigValueWrapper< gum::CausalModel< double > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "CausalModel_inducedCausalSubModel", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_inducedCausalSubModel" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CausalModel_inducedCausalSubModel" "', argument " "2"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CausalModel_inducedCausalSubModel" "', argument " "2"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::CausalModel< double > * >(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 '" "CausalModel_inducedCausalSubModel" "', argument " "3"" of type '" "gum::NodeSet""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CausalModel_inducedCausalSubModel" "', argument " "3"" of type '" "gum::NodeSet""'");
    } else {
      gum::NodeSet * temp = reinterpret_cast< gum::NodeSet * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->inducedCausalSubModel((gum::CausalModel< double > const &)*arg2,SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::CausalModel< double >(result)), SWIGTYPE_p_gum__CausalModelT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_toDot__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  bool arg2 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  char *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_toDot" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CausalModel_toDot" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CausalModel_toDot" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CausalModel_toDot" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CausalModel_toDot" "', argument " "5"" of type '" "char const *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->toDot(arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_toDot__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  bool arg2 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_toDot" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CausalModel_toDot" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CausalModel_toDot" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CausalModel_toDot" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->toDot(arg2,(char const *)arg3,(char const *)arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_toDot__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  bool arg2 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_toDot" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CausalModel_toDot" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CausalModel_toDot" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->toDot(arg2,(char const *)arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_toDot__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_toDot" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CausalModel_toDot" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->toDot(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_toDot__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< 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__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_toDot" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    try {
      result = ((gum::CausalModel< 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_CausalModel_toDot(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CausalModel_toDot", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_CausalModel_toDot__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_CausalModel_toDot__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_CausalModel_toDot__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_CausalModel_toDot__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_CausalModel_toDot__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 'CausalModel_toDot'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalModel< double >::toDot(bool const,char const *,char const *,char const *) const\n"
    "    gum::CausalModel< double >::toDot(bool const,char const *,char const *) const\n"
    "    gum::CausalModel< double >::toDot(bool const,char const *) const\n"
    "    gum::CausalModel< double >::toDot(bool const) const\n"
    "    gum::CausalModel< double >::toDot() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CausalModel_observationalBN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalModel< 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__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_observationalBN" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    try {
      result = (gum::BayesNet< double > *) &((gum::CausalModel< double > const *)arg1)->observationalBN();
    } 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_CausalModel_causalDAG(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalModel< 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__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_causalDAG" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->causalDAG();
    } 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_CausalModel_names(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::Set< std::string > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_names" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->names();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromStringSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_idFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "CausalModel_idFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_idFromName" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->idFromName(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_nameFromId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalModel< 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;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "CausalModel_nameFromId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_nameFromId" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CausalModel_nameFromId" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::CausalModel< double > 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_CausalModel_latentVariablesIds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< 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__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_latentVariablesIds" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->latentVariablesIds();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_latentVariablesNames(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::Set< std::string > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_latentVariablesNames" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->latentVariablesNames();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromStringSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_parents__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *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__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_parents" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CausalModel_parents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->parents(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_parents__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_parents" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->parents(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_parents(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CausalModel_parents", 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_CausalModel_parents__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_CausalModel_parents__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 'CausalModel_parents'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalModel< double >::parents(gum::NodeId) const\n"
    "    gum::CausalModel< double >::parents(std::string_view) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CausalModel_children__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *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__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_children" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CausalModel_children" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->children(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_children__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  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__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_children" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::CausalModel< double > const *)arg1)->children(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(result);
  }
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_children(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CausalModel_children", 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_CausalModel_children__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_CausalModel_children__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 'CausalModel_children'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalModel< double >::children(gum::NodeId) const\n"
    "    gum::CausalModel< double >::children(std::string_view) const\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_CausalModel_variable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< 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__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_variable" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CausalModel_variable" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::CausalModel< 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_CausalModel_variable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  gum::DiscreteVariable *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalModelT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalModel_variable" "', argument " "1"" of type '" "gum::CausalModel< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::CausalModel< 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 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalModel_variable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CausalModel_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_CausalModel_variable__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_CausalModel_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 'CausalModel_variable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalModel< double >::variable(gum::NodeId) const\n"
    "    gum::CausalModel< double >::variable(std::string_view) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_CausalModel__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  gum::CausalModel< double > *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 '" "new_CausalModel" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CausalModel" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CausalModel" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (gum::CausalModel< double > *)new_gum_CausalModel_Sl_double_Sg___SWIG_5((gum::BayesNet< double > const &)*arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CausalModelT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CausalModel__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::CausalModel< 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_CausalModel" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CausalModel" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (gum::CausalModel< double > *)new_gum_CausalModel_Sl_double_Sg___SWIG_5((gum::BayesNet< double > const &)*arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CausalModelT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CausalModel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CausalModel", 0, 3, argv))) SWIG_fail;
  --argc;
  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_1;
    return _wrap_new_CausalModel__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__CausalModelT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_CausalModel__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_CausalModel__SWIG_4(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_std__vectorT_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_std__allocatorT_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_new_CausalModel__SWIG_2(self, argc, argv);
  }
check_4:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_CausalModel__SWIG_6(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__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_std__allocatorT_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    PyObject *retobj = _wrap_new_CausalModel__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_6:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_CausalModel__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 'new_CausalModel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalModel< double >::CausalModel(gum::BayesNet< double > const &)\n"
    "    gum::CausalModel< double >::CausalModel(gum::BayesNet< double > const &,gum::LatentDescriptorVector const &,bool)\n"
    "    gum::CausalModel< double >::CausalModel(gum::BayesNet< double > const &,gum::LatentDescriptorVector const &)\n"
    "    gum::CausalModel< double >::CausalModel(gum::CausalModel< double > const &)\n"
    "    gum::CausalModel< double >::CausalModel(gum::CausalModel< double > &&)\n"
    "    gum::CausalModel< double >::CausalModel(gum::BayesNet< double > const &,PyObject *,bool)\n"
    "    gum::CausalModel< double >::CausalModel(gum::BayesNet< double > const &,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *CausalModel_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__CausalModelT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

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

SWIGINTERN PyObject *_wrap_CausalImpact_eval(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalImpact< 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__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_eval" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    try {
      result = ((gum::CausalImpact< double > const *)arg1)->eval();
    } 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_CausalImpact_toString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalImpact< 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__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_toString" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    try {
      result = ((gum::CausalImpact< 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_CausalImpact_toLatex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalImpact< double > *arg1 = 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  std::string result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_toLatex" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::CausalImpact< double > const *)arg1)->toLatex(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalImpact_toLatex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalImpact< double > *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  std::string result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_toLatex" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::CausalImpact< double > const *)arg1)->toLatex(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalImpact_toLatex__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalImpact< 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__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_toLatex" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    try {
      result = ((gum::CausalImpact< double > const *)arg1)->toLatex();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalImpact_toLatex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CausalImpact_toLatex", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_CausalImpact_toLatex__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_CausalImpact_toLatex__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_CausalImpact_toLatex__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 'CausalImpact_toLatex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalImpact< double >::toLatex(std::string_view,std::string_view) const\n"
    "    gum::CausalImpact< double >::toLatex(std::string_view) const\n"
    "    gum::CausalImpact< double >::toLatex() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CausalImpact_latexQuery__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalImpact< double > *arg1 = 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  std::string result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_latexQuery" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::CausalImpact< double > const *)arg1)->latexQuery(SWIG_STD_MOVE(*(&arg2)),SWIG_STD_MOVE(*(&arg3)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalImpact_latexQuery__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalImpact< double > *arg1 = 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  std::string result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_latexQuery" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      result = ((gum::CausalImpact< double > const *)arg1)->latexQuery(SWIG_STD_MOVE(*(&arg2)));
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalImpact_latexQuery__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalImpact< 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__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_latexQuery" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    try {
      result = ((gum::CausalImpact< double > const *)arg1)->latexQuery();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalImpact_latexQuery(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CausalImpact_latexQuery", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_CausalImpact_latexQuery__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_CausalImpact_latexQuery__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_CausalImpact_latexQuery__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 'CausalImpact_latexQuery'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalImpact< double >::latexQuery(std::string_view,std::string_view) const\n"
    "    gum::CausalImpact< double >::latexQuery(std::string_view) const\n"
    "    gum::CausalImpact< double >::latexQuery() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CausalImpact_isIdentified(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalImpact< 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__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_isIdentified" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    try {
      result = (bool)((gum::CausalImpact< double > const *)arg1)->isIdentified();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_CausalImpact_on(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalImpact< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeSet *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_on" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    try {
      result = (gum::NodeSet *) &((gum::CausalImpact< double > const *)arg1)->on();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalImpact_doing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalImpact< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeSet *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_doing" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    try {
      result = (gum::NodeSet *) &((gum::CausalImpact< double > const *)arg1)->doing();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalImpact_knowing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalImpact< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeSet *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_knowing" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    try {
      result = (gum::NodeSet *) &((gum::CausalImpact< double > const *)arg1)->knowing();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromNodeSet(*result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalImpact_explanation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalImpact< double > *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__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_explanation" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    try {
      result = (std::string *) &((gum::CausalImpact< double > const *)arg1)->explanation();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalImpact_onNames(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalImpact< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< 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__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_onNames" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    try {
      result = ((gum::CausalImpact< double > const *)arg1)->onNames();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    std::vector<std::string> _v = std::move(result);
    Py_ssize_t _n = static_cast<Py_ssize_t>(_v.size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyUnicode_FromString(_v[_i].c_str()));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalImpact_doingNames(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalImpact< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< 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__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_doingNames" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    try {
      result = ((gum::CausalImpact< double > const *)arg1)->doingNames();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    std::vector<std::string> _v = std::move(result);
    Py_ssize_t _n = static_cast<Py_ssize_t>(_v.size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyUnicode_FromString(_v[_i].c_str()));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CausalImpact_knowingNames(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalImpact< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< 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__CausalImpactT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CausalImpact_knowingNames" "', argument " "1"" of type '" "gum::CausalImpact< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    try {
      result = ((gum::CausalImpact< double > const *)arg1)->knowingNames();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    std::vector<std::string> _v = std::move(result);
    Py_ssize_t _n = static_cast<Py_ssize_t>(_v.size());
    resultobj = PyTuple_New(_n);
    for (Py_ssize_t _i = 0; _i < _n; ++_i)
    PyTuple_SET_ITEM(resultobj, _i, PyUnicode_FromString(_v[_i].c_str()));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CausalImpact__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::Set< std::string > *arg2 = 0 ;
  gum::Set< std::string > *arg3 = 0 ;
  gum::Set< std::string > *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Set< std::string > temp2 ;
  gum::Set< std::string > temp3 ;
  gum::Set< std::string > temp4 ;
  bool val5 ;
  int ecode5 = 0 ;
  gum::CausalImpact< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CausalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CausalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp2, swig_obj[1]);
    arg2 = &temp2;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp3, swig_obj[2]);
    arg3 = &temp3;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp4, swig_obj[3]);
    arg4 = &temp4;
  }
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CausalImpact" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (gum::CausalImpact< double > *)new gum::CausalImpact< double >((gum::CausalModel< double > const &)*arg1,(gum::Set< std::string > const &)*arg2,(gum::Set< std::string > const &)*arg3,(gum::Set< std::string > const &)*arg4,arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CausalImpactT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CausalImpact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::Set< std::string > *arg2 = 0 ;
  gum::Set< std::string > *arg3 = 0 ;
  gum::Set< std::string > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Set< std::string > temp2 ;
  gum::Set< std::string > temp3 ;
  gum::Set< std::string > temp4 ;
  gum::CausalImpact< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CausalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CausalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp2, swig_obj[1]);
    arg2 = &temp2;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp3, swig_obj[2]);
    arg3 = &temp3;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp4, swig_obj[3]);
    arg4 = &temp4;
  }
  {
    try {
      result = (gum::CausalImpact< double > *)new gum::CausalImpact< double >((gum::CausalModel< double > const &)*arg1,(gum::Set< std::string > const &)*arg2,(gum::Set< std::string > const &)*arg3,(gum::Set< std::string > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CausalImpactT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CausalImpact__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::Set< std::string > *arg2 = 0 ;
  gum::Set< std::string > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Set< std::string > temp2 ;
  gum::Set< std::string > temp3 ;
  gum::CausalImpact< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CausalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CausalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp2, swig_obj[1]);
    arg2 = &temp2;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp3, swig_obj[2]);
    arg3 = &temp3;
  }
  {
    try {
      result = (gum::CausalImpact< double > *)new gum::CausalImpact< double >((gum::CausalModel< double > const &)*arg1,(gum::Set< std::string > const &)*arg2,(gum::Set< std::string > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CausalImpactT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CausalImpact__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  gum::NodeSet *arg3 = 0 ;
  gum::NodeSet *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  gum::NodeSet _ns_temp4 ;
  bool val5 ;
  int ecode5 = 0 ;
  gum::CausalImpact< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CausalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CausalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CausalImpact" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (gum::CausalImpact< double > *)new gum::CausalImpact< double >((gum::CausalModel< double > const &)*arg1,(gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3,(gum::NodeSet const &)*arg4,arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CausalImpactT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CausalImpact__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  gum::NodeSet *arg3 = 0 ;
  gum::NodeSet *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  gum::NodeSet _ns_temp4 ;
  gum::CausalImpact< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CausalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CausalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[3]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp4.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg4 = &_ns_temp4;
  }
  {
    try {
      result = (gum::CausalImpact< double > *)new gum::CausalImpact< double >((gum::CausalModel< double > const &)*arg1,(gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3,(gum::NodeSet const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CausalImpactT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CausalImpact__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  gum::NodeSet *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  gum::CausalImpact< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CausalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CausalImpact" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    try {
      result = (gum::CausalImpact< double > *)new gum::CausalImpact< double >((gum::CausalModel< double > const &)*arg1,(gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CausalImpactT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


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


SWIGINTERN PyObject *_wrap_new_CausalImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CausalImpact", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__CausalImpactT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_CausalImpact__SWIG_6(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_CausalImpact__SWIG_7(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_3;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_3;
    return _wrap_new_CausalImpact__SWIG_5(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_CausalImpact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_5;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_5;
    {
      {
        if (PySet_Check(argv[3]) || PyFrozenSet_Check(argv[3])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[3]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_5;
    return _wrap_new_CausalImpact__SWIG_4(self, argc, argv);
  }
check_5:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_new_CausalImpact__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    int _v = 0;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_7;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_7;
    {
      {
        if (PySet_Check(argv[3]) || PyFrozenSet_Check(argv[3])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[3]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_7;
    PyObject *retobj = _wrap_new_CausalImpact__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_7:
  
  if (argc == 5) {
    PyObject *retobj = _wrap_new_CausalImpact__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_CausalImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CausalImpact< double >::CausalImpact(gum::CausalModel< double > const &,gum::Set< std::string > const &,gum::Set< std::string > const &,gum::Set< std::string > const &,bool)\n"
    "    gum::CausalImpact< double >::CausalImpact(gum::CausalModel< double > const &,gum::Set< std::string > const &,gum::Set< std::string > const &,gum::Set< std::string > const &)\n"
    "    gum::CausalImpact< double >::CausalImpact(gum::CausalModel< double > const &,gum::Set< std::string > const &,gum::Set< std::string > const &)\n"
    "    gum::CausalImpact< double >::CausalImpact(gum::CausalModel< double > const &,gum::NodeSet const &,gum::NodeSet const &,gum::NodeSet const &,bool)\n"
    "    gum::CausalImpact< double >::CausalImpact(gum::CausalModel< double > const &,gum::NodeSet const &,gum::NodeSet const &,gum::NodeSet const &)\n"
    "    gum::CausalImpact< double >::CausalImpact(gum::CausalModel< double > const &,gum::NodeSet const &,gum::NodeSet const &)\n"
    "    gum::CausalImpact< double >::CausalImpact(gum::CausalImpact< double > const &)\n"
    "    gum::CausalImpact< double >::CausalImpact(gum::CausalImpact< double > &&)\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_delete_CausalImpact(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalImpact< 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__CausalImpactT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CausalImpact" "', argument " "1"" of type '" "gum::CausalImpact< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalImpact< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CausalImpact_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__CausalImpactT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

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

SWIGINTERN PyObject *_wrap_new_Counterfactual__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::Set< std::string > *arg2 = 0 ;
  gum::Set< std::string > *arg3 = 0 ;
  gum::HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > *arg4 = 0 ;
  gum::HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Set< std::string > temp2 ;
  gum::Set< std::string > temp3 ;
  gum::HashTable< std::string,std::string > temp4 ;
  gum::HashTable< std::string,std::string > temp5 ;
  gum::Counterfactual< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp2, swig_obj[1]);
    arg2 = &temp2;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp3, swig_obj[2]);
    arg3 = &temp3;
  }
  {
    PyAgrumHelper::populateHashTableStrStrFromPyDict(temp4, swig_obj[3]);
    arg4 = &temp4;
  }
  {
    PyAgrumHelper::populateHashTableStrStrFromPyDict(temp5, swig_obj[4]);
    arg5 = &temp5;
  }
  {
    try {
      result = (gum::Counterfactual< double > *)new gum::Counterfactual< double >((gum::CausalModel< double > const &)*arg1,(gum::Set< std::string > const &)*arg2,(gum::Set< std::string > const &)*arg3,(gum::HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > const &)*arg4,(gum::HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > const &)*arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CounterfactualT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Counterfactual__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::Set< std::string > *arg2 = 0 ;
  gum::Set< std::string > *arg3 = 0 ;
  gum::HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Set< std::string > temp2 ;
  gum::Set< std::string > temp3 ;
  gum::HashTable< std::string,std::string > temp4 ;
  gum::Counterfactual< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp2, swig_obj[1]);
    arg2 = &temp2;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp3, swig_obj[2]);
    arg3 = &temp3;
  }
  {
    PyAgrumHelper::populateHashTableStrStrFromPyDict(temp4, swig_obj[3]);
    arg4 = &temp4;
  }
  {
    try {
      result = (gum::Counterfactual< double > *)new gum::Counterfactual< double >((gum::CausalModel< double > const &)*arg1,(gum::Set< std::string > const &)*arg2,(gum::Set< std::string > const &)*arg3,(gum::HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CounterfactualT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Counterfactual__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::Set< std::string > *arg2 = 0 ;
  gum::Set< std::string > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Set< std::string > temp2 ;
  gum::Set< std::string > temp3 ;
  gum::Counterfactual< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp2, swig_obj[1]);
    arg2 = &temp2;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp3, swig_obj[2]);
    arg3 = &temp3;
  }
  {
    try {
      result = (gum::Counterfactual< double > *)new gum::Counterfactual< double >((gum::CausalModel< double > const &)*arg1,(gum::Set< std::string > const &)*arg2,(gum::Set< std::string > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CounterfactualT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Counterfactual__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  gum::NodeSet *arg3 = 0 ;
  gum::HashTable< gum::NodeId,gum::Idx > *arg4 = 0 ;
  gum::HashTable< gum::NodeId,gum::Idx > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  gum::Counterfactual< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HashTableT_std__size_t_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Counterfactual" "', argument " "4"" of type '" "HashTable< gum::NodeId,gum::Idx > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Counterfactual" "', argument " "4"" of type '" "HashTable< gum::NodeId,gum::Idx > const &""'"); 
  }
  arg4 = reinterpret_cast< gum::HashTable< gum::NodeId,gum::Idx > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HashTableT_std__size_t_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Counterfactual" "', argument " "5"" of type '" "HashTable< gum::NodeId,gum::Idx > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Counterfactual" "', argument " "5"" of type '" "HashTable< gum::NodeId,gum::Idx > const &""'"); 
  }
  arg5 = reinterpret_cast< gum::HashTable< gum::NodeId,gum::Idx > * >(argp5);
  {
    try {
      result = (gum::Counterfactual< double > *)new gum::Counterfactual< double >((gum::CausalModel< double > const &)*arg1,(gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3,(gum::HashTable< gum::NodeId,gum::Idx > const &)*arg4,(gum::HashTable< gum::NodeId,gum::Idx > const &)*arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CounterfactualT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Counterfactual__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  gum::NodeSet *arg3 = 0 ;
  gum::HashTable< gum::NodeId,gum::Idx > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  gum::Counterfactual< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HashTableT_std__size_t_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Counterfactual" "', argument " "4"" of type '" "HashTable< gum::NodeId,gum::Idx > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Counterfactual" "', argument " "4"" of type '" "HashTable< gum::NodeId,gum::Idx > const &""'"); 
  }
  arg4 = reinterpret_cast< gum::HashTable< gum::NodeId,gum::Idx > * >(argp4);
  {
    try {
      result = (gum::Counterfactual< double > *)new gum::Counterfactual< double >((gum::CausalModel< double > const &)*arg1,(gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3,(gum::HashTable< gum::NodeId,gum::Idx > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CounterfactualT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Counterfactual__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::NodeSet *arg2 = 0 ;
  gum::NodeSet *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeSet _ns_temp2 ;
  gum::NodeSet _ns_temp3 ;
  gum::Counterfactual< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[1]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp2.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg2 = &_ns_temp2;
  }
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    try {
      result = (gum::Counterfactual< double > *)new gum::Counterfactual< double >((gum::CausalModel< double > const &)*arg1,(gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CounterfactualT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Counterfactual(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Counterfactual", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_1;
    return _wrap_new_Counterfactual__SWIG_5(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_Counterfactual__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_3;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HashTableT_std__size_t_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_Counterfactual__SWIG_4(self, argc, argv);
  }
check_3:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_new_Counterfactual__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    int _v = 0;
    {
      {
        if (PySet_Check(argv[1]) || PyFrozenSet_Check(argv[1])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[1]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_5;
    {
      {
        if (PySet_Check(argv[2]) || PyFrozenSet_Check(argv[2])) {
          _v = 1;
          PyObject* _tc_iter = PyObject_GetIter(argv[2]);
          if (_tc_iter) {
            PyObject* _tc_item;
            while (_v && (_tc_item = PyIter_Next(_tc_iter)) != nullptr) {
              if (PyUnicode_Check(_tc_item)) {
                _v = 0; 
              }
              Py_DECREF(_tc_item);
            }
            Py_DECREF(_tc_iter);
          }
        } else {
          _v = 0;
        }
      }
    }
    if (!_v) goto check_5;
    {
      int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HashTableT_std__size_t_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    {
      int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HashTableT_std__size_t_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    return _wrap_new_Counterfactual__SWIG_3(self, argc, argv);
  }
check_5:
  
  if (argc == 5) {
    PyObject *retobj = _wrap_new_Counterfactual__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_Counterfactual'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Counterfactual< double >::Counterfactual(gum::CausalModel< double > const &,gum::Set< std::string > const &,gum::Set< std::string > const &,HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > const &,HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > const &)\n"
    "    gum::Counterfactual< double >::Counterfactual(gum::CausalModel< double > const &,gum::Set< std::string > const &,gum::Set< std::string > const &,HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > const &)\n"
    "    gum::Counterfactual< double >::Counterfactual(gum::CausalModel< double > const &,gum::Set< std::string > const &,gum::Set< std::string > const &)\n"
    "    gum::Counterfactual< double >::Counterfactual(gum::CausalModel< double > const &,gum::NodeSet const &,gum::NodeSet const &,HashTable< gum::NodeId,gum::Idx > const &,HashTable< gum::NodeId,gum::Idx > const &)\n"
    "    gum::Counterfactual< double >::Counterfactual(gum::CausalModel< double > const &,gum::NodeSet const &,gum::NodeSet const &,HashTable< gum::NodeId,gum::Idx > const &)\n"
    "    gum::Counterfactual< double >::Counterfactual(gum::CausalModel< double > const &,gum::NodeSet const &,gum::NodeSet const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Counterfactual_counterFactualModel__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > *arg2 = 0 ;
  gum::Set< std::string > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::HashTable< std::string,std::string > temp2 ;
  gum::Set< std::string > temp3 ;
  SwigValueWrapper< gum::CausalModel< double > > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Counterfactual_counterFactualModel" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Counterfactual_counterFactualModel" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyAgrumHelper::populateHashTableStrStrFromPyDict(temp2, swig_obj[1]);
    arg2 = &temp2;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp3, swig_obj[2]);
    arg3 = &temp3;
  }
  {
    try {
      result = gum::Counterfactual< double >::SWIGTEMPLATEDISAMBIGUATOR counterFactualModel((gum::CausalModel< double > const &)*arg1,(gum::HashTable< std::string,std::string > const &)*arg2,(gum::Set< std::string > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::CausalModel< double >(result)), SWIGTYPE_p_gum__CausalModelT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Counterfactual_counterFactualModel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::HashTable< gum::NodeId,gum::Idx > *arg2 = 0 ;
  gum::NodeSet *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeSet _ns_temp3 ;
  SwigValueWrapper< gum::CausalModel< double > > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Counterfactual_counterFactualModel" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Counterfactual_counterFactualModel" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HashTableT_std__size_t_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Counterfactual_counterFactualModel" "', argument " "2"" of type '" "HashTable< gum::NodeId,gum::Idx > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Counterfactual_counterFactualModel" "', argument " "2"" of type '" "HashTable< gum::NodeId,gum::Idx > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::HashTable< gum::NodeId,gum::Idx > * >(argp2);
  {
    PyObject* _iter = PyObject_GetIter(swig_obj[2]);
    if (!_iter) {
      PyErr_SetString(PyExc_TypeError, "expected an iterable of int (node IDs)");
      SWIG_fail;
    }
    PyObject* _item;
    while ((_item = PyIter_Next(_iter)) != nullptr) {
      long _val = PyLong_AsLong(_item);
      Py_DECREF(_item);
      if (_val == -1 && PyErr_Occurred()) {
        Py_DECREF(_iter); SWIG_fail; 
      }
      _ns_temp3.insert(static_cast< gum::NodeId >(_val));
    }
    Py_DECREF(_iter);
    if (PyErr_Occurred()) SWIG_fail;
    arg3 = &_ns_temp3;
  }
  {
    try {
      result = gum::Counterfactual< double >::SWIGTEMPLATEDISAMBIGUATOR counterFactualModel((gum::CausalModel< double > const &)*arg1,(gum::HashTable< std::size_t,std::size_t > const &)*arg2,(gum::Set< std::size_t > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::CausalModel< double >(result)), SWIGTYPE_p_gum__CausalModelT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Counterfactual_counterFactualModel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Counterfactual_counterFactualModel", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PyDict_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    {
      {
        _v = PySet_Check(argv[2]) || PyList_Check(argv[2]) || PyUnicode_Check(argv[2]) || PyBytes_Check(argv[2]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Counterfactual_counterFactualModel__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Counterfactual_counterFactualModel__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 'Counterfactual_counterFactualModel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Counterfactual< double >::counterFactualModel(gum::CausalModel< double > const &,HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > const &,gum::Set< std::string > const &)\n"
    "    gum::Counterfactual< double >::counterFactualModel(gum::CausalModel< double > const &,HashTable< gum::NodeId,gum::Idx > const &,gum::NodeSet const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Counterfactual_run(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Counterfactual< 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__CounterfactualT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Counterfactual_run" "', argument " "1"" of type '" "gum::Counterfactual< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Counterfactual< double > * >(argp1);
  {
    try {
      (arg1)->run();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


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


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


SWIGINTERN PyObject *_wrap_Counterfactual_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Counterfactual< 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__CounterfactualT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Counterfactual_value" "', argument " "1"" of type '" "gum::Counterfactual< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Counterfactual< double > * >(argp1);
  {
    try {
      result = (gum::Tensor< double > *) &((gum::Counterfactual< double > const *)arg1)->value();
    } 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_Counterfactual_on(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Counterfactual< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Set< std::string > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CounterfactualT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Counterfactual_on" "', argument " "1"" of type '" "gum::Counterfactual< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Counterfactual< double > * >(argp1);
  {
    try {
      result = (gum::Set< std::string > *) &((gum::Counterfactual< double > const *)arg1)->on();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromStringSet(*result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Counterfactual_whatif(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Counterfactual< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Set< std::string > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CounterfactualT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Counterfactual_whatif" "', argument " "1"" of type '" "gum::Counterfactual< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Counterfactual< double > * >(argp1);
  {
    try {
      result = (gum::Set< std::string > *) &((gum::Counterfactual< double > const *)arg1)->whatif();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySetFromStringSet(*result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Counterfactual_profile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Counterfactual< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CounterfactualT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Counterfactual_profile" "', argument " "1"" of type '" "gum::Counterfactual< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Counterfactual< double > * >(argp1);
  {
    try {
      result = (gum::HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > *) &((gum::Counterfactual< double > const *)arg1)->profile();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PyDictFromHashTableStrStr(*result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Counterfactual_values(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Counterfactual< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CounterfactualT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Counterfactual_values" "', argument " "1"" of type '" "gum::Counterfactual< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Counterfactual< double > * >(argp1);
  {
    try {
      result = (gum::HashTable< gum::Counterfactual< double >::VarName,gum::Counterfactual< double >::ValName > *) &((gum::Counterfactual< double > const *)arg1)->values();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PyDictFromHashTableStrStr(*result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Counterfactual_toString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Counterfactual< 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__CounterfactualT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Counterfactual_toString" "', argument " "1"" of type '" "gum::Counterfactual< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Counterfactual< double > * >(argp1);
  {
    try {
      result = ((gum::Counterfactual< 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_delete_Counterfactual(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::Counterfactual< 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__CounterfactualT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Counterfactual" "', argument " "1"" of type '" "gum::Counterfactual< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Counterfactual< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Counterfactual_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__CounterfactualT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

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

SWIGINTERN PyObject *_wrap__counterfactual__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::Set< std::string > *arg2 = 0 ;
  gum::Set< std::string > *arg3 = 0 ;
  gum::HashTable< std::string,std::string > *arg4 = 0 ;
  gum::HashTable< std::string,std::string > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Set< std::string > temp2 ;
  gum::Set< std::string > temp3 ;
  gum::HashTable< std::string,std::string > temp4 ;
  gum::HashTable< std::string,std::string > temp5 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "_counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp2, swig_obj[1]);
    arg2 = &temp2;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp3, swig_obj[2]);
    arg3 = &temp3;
  }
  {
    PyAgrumHelper::populateHashTableStrStrFromPyDict(temp4, swig_obj[3]);
    arg4 = &temp4;
  }
  {
    PyAgrumHelper::populateHashTableStrStrFromPyDict(temp5, swig_obj[4]);
    arg5 = &temp5;
  }
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR counterfactual< double >((gum::CausalModel< double > const &)*arg1,(gum::Set< std::string > const &)*arg2,(gum::Set< std::string > const &)*arg3,(gum::HashTable< std::string,std::string > const &)*arg4,(gum::HashTable< std::string,std::string > const &)*arg5);
    } 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__counterfactual__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::Set< std::string > *arg2 = 0 ;
  gum::Set< std::string > *arg3 = 0 ;
  gum::HashTable< std::string,std::string > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Set< std::string > temp2 ;
  gum::Set< std::string > temp3 ;
  gum::HashTable< std::string,std::string > temp4 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "_counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp2, swig_obj[1]);
    arg2 = &temp2;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp3, swig_obj[2]);
    arg3 = &temp3;
  }
  {
    PyAgrumHelper::populateHashTableStrStrFromPyDict(temp4, swig_obj[3]);
    arg4 = &temp4;
  }
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR counterfactual< double >((gum::CausalModel< double > const &)*arg1,(gum::Set< std::string > const &)*arg2,(gum::Set< std::string > const &)*arg3,(gum::HashTable< std::string,std::string > const &)*arg4);
    } 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__counterfactual__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::Set< std::string > *arg2 = 0 ;
  gum::Set< std::string > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Set< std::string > temp2 ;
  gum::Set< std::string > temp3 ;
  gum::Tensor< double > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "_counterfactual" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp2, swig_obj[1]);
    arg2 = &temp2;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp3, swig_obj[2]);
    arg3 = &temp3;
  }
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR counterfactual< double >((gum::CausalModel< double > const &)*arg1,(gum::Set< std::string > const &)*arg2,(gum::Set< 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 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__counterfactual(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "_counterfactual", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap__counterfactual__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap__counterfactual__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap__counterfactual__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 '_counterfactual'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::counterfactual< double >(gum::CausalModel< double > const &,gum::Set< std::string > const &,gum::Set< std::string > const &,HashTable< std::string,std::string > const &,HashTable< std::string,std::string > const &)\n"
    "    gum::counterfactual< double >(gum::CausalModel< double > const &,gum::Set< std::string > const &,gum::Set< std::string > const &,HashTable< std::string,std::string > const &)\n"
    "    gum::counterfactual< double >(gum::CausalModel< double > const &,gum::Set< std::string > const &,gum::Set< std::string > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap__counterfactualModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  gum::CausalModel< double > *arg1 = 0 ;
  gum::HashTable< std::string,std::string > *arg2 = 0 ;
  gum::Set< std::string > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::HashTable< std::string,std::string > temp2 ;
  gum::Set< std::string > temp3 ;
  PyObject *swig_obj[3] ;
  SwigValueWrapper< gum::CausalModel< double > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_counterfactualModel", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CausalModelT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_counterfactualModel" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "_counterfactualModel" "', argument " "1"" of type '" "gum::CausalModel< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CausalModel< double > * >(argp1);
  {
    PyAgrumHelper::populateHashTableStrStrFromPyDict(temp2, swig_obj[1]);
    arg2 = &temp2;
  }
  {
    PyAgrumHelper::populateStringSetFromPySequence(temp3, swig_obj[2]);
    arg3 = &temp3;
  }
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR counterfactualModel< double >((gum::CausalModel< double > const &)*arg1,(gum::HashTable< std::string,std::string > const &)*arg2,(gum::Set< std::string > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::CausalModel< double >(result)), SWIGTYPE_p_gum__CausalModelT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


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_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 of list of 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 of list of 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 of list of 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},
	 { "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_HedgeException", _wrap_new_HedgeException, METH_VARARGS, NULL},
	 { "delete_HedgeException", _wrap_delete_HedgeException, METH_O, NULL},
	 { "HedgeException_swigregister", HedgeException_swigregister, METH_O, NULL},
	 { "HedgeException_swiginit", HedgeException_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, "\n"
		"\n"
		"Return the name of the file in which the syntax error occurred.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    the name of the file containing the syntax error\n"
		"\n"
		""},
	 { "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},
	 { "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"
		""},
	 { "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"
		"index : int\n"
		"    an index\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the numerical representation of the value at the given index\n"
		"\n"
		""},
	 { "DiscreteVariable_isEmpirical", _wrap_DiscreteVariable_isEmpirical, METH_O, NULL},
	 { "DiscreteVariable_isNumerical", _wrap_DiscreteVariable_isNumerical, METH_O, "\n"
		"\n"
		"Returns True if the variable has a meaningful numerical representation, i.e. it is not a LabelizedVariable.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True for DiscretizedVariable, IntegerVariable, NumericalDiscreteVariable and RangeVariable; False for LabelizedVariable.\n"
		"\n"
		""},
	 { "DiscreteVariable_closestIndex", _wrap_DiscreteVariable_closestIndex, METH_VARARGS, "\n"
		"\n"
		"For numerical discrete variables (all except 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"
		"val : 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 gum.LabelizedVariable).\n"
		"\n"
		""},
	 { "DiscreteVariable_closestLabel", _wrap_DiscreteVariable_closestLabel, METH_VARARGS, "\n"
		"\n"
		"For numerical discrete variables (all except 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"
		"val : 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 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: NumericalDiscreteVariable, 4: RangeVariable\n"
		"\n"
		""},
	 { "DiscreteVariable_toFast", _wrap_DiscreteVariable_toFast, METH_O, "\n"
		"\n"
		"Return the variable description in fast syntax (e.g. ``name[val1|val2|...]``).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    fast-syntax string representation\n"
		"\n"
		""},
	 { "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 index 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 label at the given index\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 index 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 label at the given index\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, "\n"
		"\n"
		"Return the position (index) of a label in the variable's domain.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"label : str\n"
		"    the label to look up\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the index of the label in the domain\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if the label does not exist in the domain\n"
		"\n"
		""},
	 { "LabelizedVariable_numerical", _wrap_LabelizedVariable_numerical, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"index : int\n"
		"    an index\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the numerical representation of the value at the given index\n"
		"\n"
		""},
	 { "LabelizedVariable_closestIndex", _wrap_LabelizedVariable_closestIndex, METH_VARARGS, "\n"
		"\n"
		"For numerical discrete variables (all except 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"
		"val : 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 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: NumericalDiscreteVariable, 4: RangeVariable\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, "\n"
		"\n"
		"Return the variable description in fast syntax (e.g. ``name[val1|val2|...]``).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    fast-syntax string representation\n"
		"\n"
		""},
	 { "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: NumericalDiscreteVariable, 4: RangeVariable\n"
		"\n"
		""},
	 { "RangeVariable_toFast", _wrap_RangeVariable_toFast, METH_O, "\n"
		"\n"
		"Return the variable description in fast syntax (e.g. ``name[min,max]``).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    fast-syntax string representation\n"
		"\n"
		""},
	 { "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"
		"index : int\n"
		"    an index\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the numerical representation of the value at the given index\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 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"
		"val : 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 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: NumericalDiscreteVariable, 4: RangeVariable\n"
		"\n"
		""},
	 { "IntegerVariable_toFast", _wrap_IntegerVariable_toFast, METH_O, "\n"
		"\n"
		"Return the variable description in fast syntax (e.g. ``name{v1|v2|...}``).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    fast-syntax string representation\n"
		"\n"
		""},
	 { "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 index of the label\n"
		"\n"
		""},
	 { "IntegerVariable_closestIndex", _wrap_IntegerVariable_closestIndex, METH_VARARGS, "\n"
		"\n"
		"For numerical discrete variables (all except 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"
		"val : 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 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 label at the given index\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"
		"index : int\n"
		"    an index\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the numerical representation of the value at the given index\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\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 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"
		"val : 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 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: NumericalDiscreteVariable, 4: RangeVariable\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable_toFast", _wrap_NumericalDiscreteVariable_toFast, METH_O, "\n"
		"\n"
		"Return the variable description in fast syntax (e.g. ``name{v1|v2|...}``).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    fast-syntax string representation\n"
		"\n"
		""},
	 { "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 index of the label\n"
		"\n"
		""},
	 { "NumericalDiscreteVariable_closestIndex", _wrap_NumericalDiscreteVariable_closestIndex, METH_VARARGS, "\n"
		"\n"
		"For numerical discrete variables (all except 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"
		"val : 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 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 label at the given index\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"
		"index : int\n"
		"    an index\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the numerical representation of the value at the given index\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 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"
		"val : 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 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, "\n"
		"\n"
		"Check whether the variable uses relaxed (empirical) tick bounds.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the variable is in empirical mode\n"
		"\n"
		""},
	 { "IDiscretizedVariable_setEmpirical", _wrap_IDiscretizedVariable_setEmpirical, METH_VARARGS, "\n"
		"\n"
		"Enable or disable empirical (relaxed bounds) mode for the variable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"state : bool\n"
		"    True to enable empirical mode, False to disable\n"
		"\n"
		""},
	 { "IDiscretizedVariable_draw", _wrap_IDiscretizedVariable_draw, METH_VARARGS, "\n"
		"\n"
		"Draw a random index from the variable's domain.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the index of the drawn value\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Create a complete undirected graph with n nodes.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int\n"
		"    number of nodes\n"
		"\n"
		"Returns\n"
		"-------\n"
		"UndiGraph\n"
		"    graph where every pair of distinct nodes is connected by an edge, with nodes 0..n-1\n"
		"\n"
		""},
	 { "UndiGraph___eq__", _wrap_UndiGraph___eq__, 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_chainComponents", _wrap_UndiGraph_chainComponents, METH_O, "\n"
		"\n"
		"Return the chain components (connected components) of the graph.\n"
		"\n"
		"Each node is mapped to the id of its component root (an arbitrarily chosen node from the same component).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict[int, int]\n"
		"    mapping node id → component root id\n"
		"\n"
		""},
	 { "UndiGraph_connectedComponents", _wrap_UndiGraph_connectedComponents, METH_O, "\n"
		"\n"
		"Returns the connected components of the graph.\n"
		"\n"
		"Each node is mapped to the id of its component root (an arbitrarily chosen\n"
		"node from the same component).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict[int, int]\n"
		"    mapping node id → component root id\n"
		"\n"
		"See Also\n"
		"--------\n"
		"connectedComponentsList : returns a dict[int, set[int]] grouping nodes by component\n"
		"connectedComponentsCount : returns the number of components\n"
		"\n"
		""},
	 { "UndiGraph_undirectedPath", _wrap_UndiGraph_undirectedPath, METH_VARARGS, "\n"
		"\n"
		"Return a shortest undirected path between two nodes, or None if no path exists.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node1 : int\n"
		"    id of the first node\n"
		"node2 : int\n"
		"    id of the second node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list[int] or None\n"
		"    ordered list of node ids along the path, or None if the nodes are disconnected\n"
		"\n"
		""},
	 { "UndiGraph_hasUndirectedPath", _wrap_UndiGraph_hasUndirectedPath, METH_VARARGS, "\n"
		"\n"
		"Check whether two nodes are connected by an undirected path.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n1 : int\n"
		"    id of the first node\n"
		"n2 : int\n"
		"    id of the second node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if a path exists between n1 and n2\n"
		"\n"
		""},
	 { "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_nameFromId", _wrap_UndiGraph_nameFromId, METH_VARARGS, "\n"
		"\n"
		"Return the name of a node, or its id as a string if no name was set.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the node id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    the name associated with the node, or ``str(id)`` if the node has no name\n"
		"\n"
		""},
	 { "UndiGraph_idFromName", _wrap_UndiGraph_idFromName, METH_VARARGS, "\n"
		"\n"
		"Return the id of the node with the given name, or None if no such name exists.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the name to look up\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int or None\n"
		"    the node id, or None if the name is not found\n"
		"\n"
		""},
	 { "UndiGraph_setName", _wrap_UndiGraph_setName, METH_VARARGS, "\n"
		"\n"
		"Assign a name to a node.\n"
		"\n"
		"If the node already has a name, it is replaced. The name must not already be\n"
		"used by another node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the node id\n"
		"name : str\n"
		"    the name to assign\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidNode\n"
		"    If the node does not exist.\n"
		"pyagrum.DuplicateElement\n"
		"    If the name is already used by a different node.\n"
		"\n"
		""},
	 { "UndiGraph_hasName", _wrap_UndiGraph_hasName, METH_VARARGS, "\n"
		"\n"
		"Check whether a node has an explicitly assigned name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the node id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if a name has been assigned to this node via setName\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 between 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, "\n"
		"\n"
		"Create a complete directed graph with n nodes.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int\n"
		"    number of nodes\n"
		"\n"
		"Returns\n"
		"-------\n"
		"DiGraph\n"
		"    directed graph where every ordered pair (i, j) with i≠j has arc i→j, with nodes 0..n-1\n"
		"\n"
		""},
	 { "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 between 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_directedPath", _wrap_DiGraph_directedPath, METH_VARARGS, "\n"
		"\n"
		"Return a shortest directed path from node1 to node2, or None if no such path exists.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node1 : int\n"
		"    id of the source node\n"
		"node2 : int\n"
		"    id of the destination node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list[int] or None\n"
		"    ordered list of node ids along the directed path, or None if node2 is unreachable from node1\n"
		"\n"
		""},
	 { "DiGraph_directedUnorientedPath", _wrap_DiGraph_directedUnorientedPath, METH_VARARGS, "\n"
		"\n"
		"Return a shortest path from node1 to node2 ignoring arc orientation, or None if no path exists.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node1 : int\n"
		"    id of the source node\n"
		"node2 : int\n"
		"    id of the destination node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list[int] or None\n"
		"    ordered list of node ids (arcs may be traversed in either direction), or None if unreachable\n"
		"\n"
		""},
	 { "DiGraph_family", _wrap_DiGraph_family, METH_VARARGS, "\n"
		"\n"
		"Return the family of a node: the node itself plus all its parents.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"norid : int\n"
		"    id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set[int]\n"
		"    {norid} ∪ parents(norid)\n"
		"\n"
		""},
	 { "DiGraph_connectedComponents", _wrap_DiGraph_connectedComponents, METH_O, "\n"
		"\n"
		"Returns the weakly connected components of the graph.\n"
		"\n"
		"Each node is mapped to the id of its component root (an arbitrarily chosen\n"
		"node from the same component).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict[int, int]\n"
		"    mapping node id → component root id\n"
		"\n"
		"See Also\n"
		"--------\n"
		"connectedComponentsList : returns a dict[int, set[int]] grouping nodes by component\n"
		"connectedComponentsCount : returns the number of components\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_nameFromId", _wrap_DiGraph_nameFromId, METH_VARARGS, "\n"
		"\n"
		"Return the name of a node, or its id as a string if no name was set.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the node id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    the name associated with the node, or ``str(id)`` if the node has no name\n"
		"\n"
		""},
	 { "DiGraph_idFromName", _wrap_DiGraph_idFromName, METH_VARARGS, "\n"
		"\n"
		"Return the id of the node with the given name, or None if no such name exists.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the name to look up\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int or None\n"
		"    the node id, or None if the name is not found\n"
		"\n"
		""},
	 { "DiGraph_setName", _wrap_DiGraph_setName, METH_VARARGS, "\n"
		"\n"
		"Assign a name to a node.\n"
		"\n"
		"If the node already has a name, it is replaced. The name must not already be\n"
		"used by another node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the node id\n"
		"name : str\n"
		"    the name to assign\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidNode\n"
		"    If the node does not exist.\n"
		"pyagrum.DuplicateElement\n"
		"    If the name is already used by a different node.\n"
		"\n"
		""},
	 { "DiGraph_hasName", _wrap_DiGraph_hasName, METH_VARARGS, "\n"
		"\n"
		"Check whether a node has an explicitly assigned name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the node id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if a name has been assigned to this node via setName\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_descendants", _wrap_DiGraph_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\n"
		"  the set of ids of the descendants of node `norid`.\n"
		"\n"
		""},
	 { "DiGraph_ancestors", _wrap_DiGraph_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\n"
		"  the set of ids of the ancestors of node `norid`.\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 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"
		"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, "\n"
		"\n"
		"Returns the moral graph of the DAG, 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"
		""},
	 { "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"
		"pyagrum.UndiGraph\n"
		"  the moralized ancestral graph of the nodes from the DAG.\n"
		"\n"
		""},
	 { "DAG_minimalCondSet", _wrap_DAG_minimalCondSet, METH_VARARGS, "\n"
		"\n"
		"Return a minimal conditioning set of a target given source nodes in the DAG.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int | str | list[int|str]\n"
		"    the target node id(s) or name(s)\n"
		"soids : list[int|str]\n"
		"    the list of source node ids or names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set[int]\n"
		"    the minimal conditioning set (as node ids)\n"
		"\n"
		""},
	 { "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_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 : int\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_descendants", _wrap_DAG_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\n"
		"  the set of ids of the descendants of node `norid`.\n"
		"\n"
		""},
	 { "DAG_ancestors", _wrap_DAG_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\n"
		"  the set of ids of the ancestors of node `norid`.\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 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"
		"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 to 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, "\n"
		"\n"
		"Check if there is an oriented path from node1 to node2 in the mixed graph (following arc directions).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node1 : int\n"
		"    the id of the start node\n"
		"node2 : int\n"
		"    the id of the end node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if such a path exists\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Return the chain component containing a given node.\n"
		"\n"
		"The chain component of a node in a mixed graph is the set of nodes reachable via undirected edges from that node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set[int]\n"
		"    the set of node ids in the same chain component\n"
		"\n"
		""},
	 { "MixedGraph_chainComponents", _wrap_MixedGraph_chainComponents, METH_O, "\n"
		"\n"
		"Return the chain components of the graph.\n"
		"\n"
		"Each node is mapped to the id of its component root (an arbitrarily chosen node from the same component).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict[int, int]\n"
		"    mapping node id → component root id\n"
		"\n"
		""},
	 { "MixedGraph_connectedComponents", _wrap_MixedGraph_connectedComponents, METH_O, "\n"
		"\n"
		"Returns the weakly connected components of the mixed graph (following both\n"
		"arcs and undirected edges in both directions).\n"
		"\n"
		"Each node is mapped to the id of its component root (an arbitrarily chosen\n"
		"node from the same component).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict[int, int]\n"
		"    mapping node id → component root id\n"
		"\n"
		"See Also\n"
		"--------\n"
		"connectedComponentsList : returns a dict[int, set[int]] grouping nodes by component\n"
		"connectedComponentsCount : returns the number of components\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Returns the set of arcs in the graph.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of the arcs\n"
		"\n"
		""},
	 { "MixedGraph_parents", _wrap_MixedGraph_parents, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the id of the child node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"    the set of parent node ids\n"
		"\n"
		""},
	 { "MixedGraph_children", _wrap_MixedGraph_children, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the id of the parent node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"    the set of all the children ids\n"
		"\n"
		""},
	 { "MixedGraph_descendants", _wrap_MixedGraph_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\n"
		"  the set of ids of the descendants of node `norid`.\n"
		"\n"
		""},
	 { "MixedGraph_ancestors", _wrap_MixedGraph_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\n"
		"  the set of ids of the ancestors of node `norid`.\n"
		"\n"
		""},
	 { "MixedGraph_edges", _wrap_MixedGraph_edges, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"    the list of the edges\n"
		"\n"
		""},
	 { "MixedGraph_neighbours", _wrap_MixedGraph_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 node ids linked to the given node by an edge\n"
		"\n"
		""},
	 { "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 between 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, "\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"
		""},
	 { "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 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"
		"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, "\n"
		"\n"
		"Returns the moral graph of the PDAG, 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"
		""},
	 { "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"
		"pyagrum.UndiGraph\n"
		"  the moralized ancestral graph of the nodes from the DAG.\n"
		"\n"
		""},
	 { "PDAG_hasMixedReallyOrientedPath", _wrap_PDAG_hasMixedReallyOrientedPath, METH_VARARGS, "\n"
		"\n"
		"Check if there is a strictly oriented path from node1 to node2 (all arcs, no edges).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node1 : int\n"
		"    the start node id\n"
		"node2 : int\n"
		"    the end node id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if such a path exists\n"
		"\n"
		""},
	 { "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_addNodes", _wrap_PDAG_addNodes, METH_VARARGS, "\n"
		"\n"
		"Add n new nodes to the graph.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int\n"
		"    the number of nodes to add\n"
		"\n"
		""},
	 { "PDAG_arcs", _wrap_PDAG_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"
		""},
	 { "PDAG_parents", _wrap_PDAG_parents, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the id of the child node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"    the set of parent node ids\n"
		"\n"
		""},
	 { "PDAG_children", _wrap_PDAG_children, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the id of the parent node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"    the set of all children ids\n"
		"\n"
		""},
	 { "PDAG_descendants", _wrap_PDAG_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\n"
		"  the set of ids of the descendants of node `norid`.\n"
		"\n"
		""},
	 { "PDAG_ancestors", _wrap_PDAG_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\n"
		"  the set of ids of the ancestors of node `norid`.\n"
		"\n"
		""},
	 { "PDAG_edges", _wrap_PDAG_edges, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"    the list of the edges\n"
		"\n"
		""},
	 { "PDAG_neighbours", _wrap_PDAG_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 node ids linked by an edge to the given node\n"
		"\n"
		""},
	 { "PDAG_boundary", _wrap_PDAG_boundary, METH_VARARGS, "\n"
		"\n"
		"Boundary of a node: neighbours (via edges), 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 adjacent node ids\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Add a new node to the graph and return its id.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the id of the new node\n"
		"\n"
		""},
	 { "PDAG_addNodeWithId", _wrap_PDAG_addNodeWithId, METH_VARARGS, "\n"
		"\n"
		"Add a node with a specific id.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the id of the new node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.DuplicateElement\n"
		"    if a node with this id already exists\n"
		"\n"
		""},
	 { "PDAG_existsNode", _wrap_PDAG_existsNode, METH_VARARGS, "\n"
		"\n"
		"Check whether a node exists.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the node id to check\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the node exists\n"
		"\n"
		""},
	 { "PDAG_size", _wrap_PDAG_size, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of nodes in the graph\n"
		"\n"
		""},
	 { "PDAG_empty", _wrap_PDAG_empty, METH_O, "\n"
		"\n"
		"Check if the graph has no nodes.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if there are no nodes in the graph\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Remove an edge from the graph.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n1 : int\n"
		"    one endpoint of the edge\n"
		"n2 : int\n"
		"    the other endpoint\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidEdge\n"
		"    if the edge does not exist\n"
		"\n"
		""},
	 { "PDAG_existsEdge", _wrap_PDAG_existsEdge, METH_VARARGS, "\n"
		"\n"
		"Check whether an edge exists between two nodes.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n1 : int\n"
		"    one endpoint\n"
		"n2 : int\n"
		"    the other endpoint\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the edge exists\n"
		"\n"
		""},
	 { "PDAG_sizeEdges", _wrap_PDAG_sizeEdges, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of edges in the graph\n"
		"\n"
		""},
	 { "PDAG_emptyEdges", _wrap_PDAG_emptyEdges, METH_O, "\n"
		"\n"
		"Check if the graph has no edges.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the graph contains no edges\n"
		"\n"
		""},
	 { "PDAG_eraseNeighbours", _wrap_PDAG_eraseNeighbours, METH_VARARGS, "\n"
		"\n"
		"Erase all edges adjacent to a given node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the id of the node\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Remove an arc from the graph.\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.InvalidArc\n"
		"    if the arc does not exist\n"
		"\n"
		""},
	 { "PDAG_existsArc", _wrap_PDAG_existsArc, METH_VARARGS, "\n"
		"\n"
		"Check whether an arc exists between two nodes.\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"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the arc (tail, head) exists\n"
		"\n"
		""},
	 { "PDAG_eraseParents", _wrap_PDAG_eraseParents, METH_VARARGS, "\n"
		"\n"
		"Erase all arcs incoming to a node from its parents.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the id of the node\n"
		"\n"
		""},
	 { "PDAG_eraseChildren", _wrap_PDAG_eraseChildren, METH_VARARGS, "\n"
		"\n"
		"Erase all arcs from a node to its children.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the id of the node\n"
		"\n"
		""},
	 { "PDAG_sizeArcs", _wrap_PDAG_sizeArcs, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of arcs in the graph\n"
		"\n"
		""},
	 { "PDAG_emptyArcs", _wrap_PDAG_emptyArcs, METH_O, "\n"
		"\n"
		"Check if the graph has no arcs.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the graph contains no arcs\n"
		"\n"
		""},
	 { "PDAG_swigregister", PDAG_swigregister, METH_O, NULL},
	 { "PDAG_swiginit", PDAG_swiginit, METH_VARARGS, NULL},
	 { "new_PAG", _wrap_new_PAG, METH_VARARGS, NULL},
	 { "delete_PAG", _wrap_delete_PAG, METH_O, NULL},
	 { "PAG_clearEdges", _wrap_PAG_clearEdges, METH_O, "\n"
		"\n"
		"Remove all edges and their endpoint marks from the PAG.\n"
		"\n"
		"Nodes are preserved; only edges and their associated marks are removed.\n"
		"\n"
		""},
	 { "PAG_eraseNode", _wrap_PAG_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"
		""},
	 { "PAG_clear", _wrap_PAG_clear, METH_O, "\n"
		"\n"
		"Remove all the nodes and edges from the graph.\n"
		"\n"
		""},
	 { "PAG_isArrowhead", _wrap_PAG_isArrowhead, METH_VARARGS, "\n"
		"\n"
		"Return True if the mark at dst (seen from src) is an arrowhead.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"src : int\n"
		"dst : int\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"\n"
		""},
	 { "PAG_isTail", _wrap_PAG_isTail, METH_VARARGS, "\n"
		"\n"
		"Return True if the mark at dst (seen from src) is a tail.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"src : int\n"
		"dst : int\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"\n"
		""},
	 { "PAG_isCircle", _wrap_PAG_isCircle, METH_VARARGS, "\n"
		"\n"
		"Return True if the mark at dst (seen from src) is a circle.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"src : int\n"
		"dst : int\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"\n"
		""},
	 { "PAG_isDefinitelyDirected", _wrap_PAG_isDefinitelyDirected, METH_VARARGS, "\n"
		"\n"
		"Return True if the edge x-y is definitely directed from x to y.\n"
		"\n"
		"An edge is definitely directed from x to y when x has a tail and y has an arrowhead.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x : int\n"
		"y : int\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"\n"
		""},
	 { "PAG_isBidirected", _wrap_PAG_isBidirected, METH_VARARGS, "\n"
		"\n"
		"Return True if both endpoints of edge (x, y) are arrowheads (bidirected edge).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x : int\n"
		"y : int\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"\n"
		""},
	 { "PAG_isDefCollider", _wrap_PAG_isDefCollider, METH_VARARGS, "\n"
		"\n"
		"Return True if z is a definite collider on the path x-z-y.\n"
		"\n"
		"z is a definite collider when both marks at z (from x and from y) are arrowheads.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x : int\n"
		"z : int\n"
		"y : int\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"\n"
		""},
	 { "PAG_toMixedGraph", _wrap_PAG_toMixedGraph, METH_O, "\n"
		"\n"
		"Convert the PAG to a MixedGraph by interpreting definite edge orientations.\n"
		"\n"
		"- Definitely directed edges become arcs.\n"
		"- Bidirected edges become two arcs (one in each direction).\n"
		"- Undirected or circle edges become undirected edges.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.MixedGraph\n"
		"\n"
		""},
	 { "PAG_toDot", _wrap_PAG_toDot, METH_O, "\n"
		"\n"
		"Return a Graphviz dot representation of the PAG.\n"
		"\n"
		"Endpoint marks are rendered as:\n"
		"- Circle: ``odot``\n"
		"- Tail: ``none``\n"
		"- Arrowhead: ``normal``\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    dot-format string\n"
		"\n"
		""},
	 { "PAG_addNode", _wrap_PAG_addNode, METH_O, "\n"
		"\n"
		"Add a new node to the PAG and return its id.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the new NodeId\n"
		"\n"
		""},
	 { "PAG_addNodes", _wrap_PAG_addNodes, METH_VARARGS, "\n"
		"\n"
		"Add n new nodes to the PAG.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int\n"
		"    number of nodes to add\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list of int\n"
		"    the new NodeIds\n"
		"\n"
		""},
	 { "PAG_addNodeWithId", _wrap_PAG_addNodeWithId, METH_VARARGS, "\n"
		"\n"
		"Add a node with a chosen id.\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"
		""},
	 { "PAG_existsNode", _wrap_PAG_existsNode, METH_VARARGS, "\n"
		"\n"
		"Check whether a node with the given id exists in the PAG.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the id to check\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the node exists\n"
		"\n"
		""},
	 { "PAG_size", _wrap_PAG_size, METH_O, "\n"
		"\n"
		"Return the number of nodes in the PAG.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    number of nodes\n"
		"\n"
		""},
	 { "PAG_empty", _wrap_PAG_empty, METH_O, "\n"
		"\n"
		"Check whether the PAG has no nodes.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the PAG contains no nodes\n"
		"\n"
		""},
	 { "PAG_eraseEdge", _wrap_PAG_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"
		""},
	 { "PAG_existsEdge", _wrap_PAG_existsEdge, METH_VARARGS, "\n"
		"\n"
		"Check whether an edge exists between two nodes.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n1 : int\n"
		"    id of one endpoint\n"
		"n2 : int\n"
		"    id of the other endpoint\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the edge exists\n"
		"\n"
		""},
	 { "PAG_sizeEdges", _wrap_PAG_sizeEdges, METH_O, "\n"
		"\n"
		"Return the number of edges in the PAG.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    number of edges\n"
		"\n"
		""},
	 { "PAG_emptyEdges", _wrap_PAG_emptyEdges, METH_O, "\n"
		"\n"
		"Check whether the PAG has no edges.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the PAG contains no edges\n"
		"\n"
		""},
	 { "PAG_eraseNeighbours", _wrap_PAG_eraseNeighbours, METH_VARARGS, "\n"
		"\n"
		"Remove all edges adjacent to a given node (and their marks).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int\n"
		"    id of the node\n"
		"\n"
		""},
	 { "PAG_addEdge", _wrap_PAG_addEdge, METH_VARARGS, "\n"
		"\n"
		"Add an edge between two nodes with specified endpoint marks.\n"
		"\n"
		"Signatures:\n"
		"\n"
		"  ``addEdge(x, y)``\n"
		"      Adds a Circle-Circle edge (both endpoints uncertain).\n"
		"\n"
		"  ``addEdge(x, y, markAtX, markAtY)``\n"
		"      Adds an edge with explicit marks. ``markAtX`` is the mark on x's side\n"
		"      (visible from y), ``markAtY`` is the mark on y's side (visible from x).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x : int\n"
		"    id of the first node\n"
		"y : int\n"
		"    id of the second node\n"
		"markAtX : int, optional\n"
		"    mark at the x endpoint (``EdgeMark_Circle``, ``EdgeMark_Tail``, or ``EdgeMark_Arrowhead``)\n"
		"markAtY : int, optional\n"
		"    mark at the y endpoint (``EdgeMark_Circle``, ``EdgeMark_Tail``, or ``EdgeMark_Arrowhead``)\n"
		"\n"
		""},
	 { "PAG_markAt", _wrap_PAG_markAt, METH_VARARGS, "\n"
		"\n"
		"Return the endpoint mark on the dst side of edge (src, dst).\n"
		"\n"
		"The mark at dst indicates what the edge says about dst from src's perspective:\n"
		"``marks_[Arc(src,dst)]`` = mark at the dst endpoint.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"src : int\n"
		"    id of the source node\n"
		"dst : int\n"
		"    id of the destination node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    ``EdgeMark_Circle`` (0), ``EdgeMark_Tail`` (1), or ``EdgeMark_Arrowhead`` (2)\n"
		"\n"
		""},
	 { "PAG_setMarkAt", _wrap_PAG_setMarkAt, METH_VARARGS, "\n"
		"\n"
		"Set the endpoint mark on the dst side of edge (src, dst).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"src : int\n"
		"    id of the source node\n"
		"dst : int\n"
		"    id of the destination node\n"
		"m : int\n"
		"    new mark: ``EdgeMark_Circle`` (0), ``EdgeMark_Tail`` (1), or ``EdgeMark_Arrowhead`` (2)\n"
		"\n"
		""},
	 { "PAG_reorientAllWith", _wrap_PAG_reorientAllWith, METH_VARARGS, "\n"
		"\n"
		"Set all endpoint marks in the PAG to the given mark.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"m : int\n"
		"    mark to set everywhere: ``EdgeMark_Circle`` (0), ``EdgeMark_Tail`` (1), or ``EdgeMark_Arrowhead`` (2)\n"
		"\n"
		""},
	 { "PAG_swigregister", PAG_swigregister, METH_O, NULL},
	 { "PAG_swiginit", PAG_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\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\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\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, "\n"
		"\n"
		"Apply Meek rules R1–R4 to orient edges in a mixed graph.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"mg : pyagrum.MixedGraph\n"
		"    the mixed graph to orient (arcs and undirected edges)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.MixedGraph\n"
		"    the partially oriented graph (may still contain undirected edges or double-headed arcs)\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Detach this Instantiation from its master, making it independently mutable.\n"
		"\n"
		"After this call, the Instantiation is no longer a slave and can be freely modified.\n"
		"\n"
		""},
	 { "Instantiation_isMutable", _wrap_Instantiation_isMutable, METH_O, "\n"
		"\n"
		"Check whether this Instantiation is currently a slave of another object (i.e., not mutable).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the Instantiation is a slave (not independently mutable)\n"
		"\n"
		""},
	 { "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\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, "\n"
		"\n"
		"Return the keys of all metadata properties of the model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple[str, ...]\n"
		"    tuple of property names (use :meth:`property` to retrieve a value by key)\n"
		"\n"
		""},
	 { "GraphicalModel_existsProperty", _wrap_GraphicalModel_existsProperty, METH_VARARGS, "\n"
		"\n"
		"Check whether a property key exists in the model's metadata.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the property name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the property exists\n"
		"\n"
		""},
	 { "GraphicalModel_updateMetaData", _wrap_GraphicalModel_updateMetaData, METH_O, "\n"
		"\n"
		"Update the model's built-in metadata (version, creation date, last modification date).\n"
		"\n"
		"This method is called automatically by writers before saving the model to a file.\n"
		"\n"
		""},
	 { "GraphicalModel_variableNodeMap", _wrap_GraphicalModel_variableNodeMap, METH_O, "\n"
		"\n"
		"Return the variable-to-node mapping of the model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.VariableNodeMap\n"
		"    the internal variable-to-node bijection\n"
		"\n"
		""},
	 { "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\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 of str\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list of 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 of str\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    The set of ids for the list of names of the graph variables\n"
		"\n"
		""},
	 { "GraphicalModel_variables", _wrap_GraphicalModel_variables, METH_VARARGS, "\n"
		"\n"
		"Return the set of variables corresponding to a list of names or a set of node ids.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"args : list[str] or set[int]\n"
		"    variable names or node ids\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.VariableSet\n"
		"    the set of corresponding variables\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Return the node id of a variable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyagrum.DiscreteVariable\n"
		"    the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the node id of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if the variable does not exist in the model\n"
		"\n"
		""},
	 { "GraphicalModel_idFromName", _wrap_GraphicalModel_idFromName, METH_VARARGS, "\n"
		"\n"
		"Return the node id of a variable given its name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the name of the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the node id of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if no variable with this name exists in the model\n"
		"\n"
		""},
	 { "GraphicalModel_variableFromName", _wrap_GraphicalModel_variableFromName, METH_VARARGS, "\n"
		"\n"
		"Return the variable with the given name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the name of the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiscreteVariable\n"
		"    the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if no variable with this name exists in the model\n"
		"\n"
		""},
	 { "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 of str|int\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|list of str|int\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|list of 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_spaceCplxToString", _wrap_GraphicalModel_spaceCplxToString, METH_VARARGS, "\n"
		"\n"
		"Return a human-readable string summarising the space complexity of a graphical model.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dSize : float\n"
		"    log10 of the joint domain size\n"
		"dim : int\n"
		"    number of independent parameters\n"
		"usedMem : int\n"
		"    memory footprint in bytes\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a string of the form ``'domainSize: X, dim: Y, mem: Z'``\n"
		"\n"
		""},
	 { "GraphicalModel_family", _wrap_GraphicalModel_family, METH_VARARGS, NULL},
	 { "GraphicalModel_swigregister", GraphicalModel_swigregister, METH_O, NULL},
	 { "delete_DiscreteGraphicalModel", _wrap_delete_DiscreteGraphicalModel, METH_O, NULL},
	 { "DiscreteGraphicalModel_variableNodeMap", _wrap_DiscreteGraphicalModel_variableNodeMap, METH_O, "\n"
		"\n"
		"Return the variable-to-node mapping of the model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.VariableNodeMap\n"
		"    the internal variable-to-node bijection\n"
		"\n"
		""},
	 { "DiscreteGraphicalModel_variable", _wrap_DiscreteGraphicalModel_variable, METH_VARARGS, NULL},
	 { "DiscreteGraphicalModel_nodeId", _wrap_DiscreteGraphicalModel_nodeId, METH_VARARGS, "\n"
		"\n"
		"Return the node id of a variable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyagrum.DiscreteVariable\n"
		"    the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the node id of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if the variable does not exist in the model\n"
		"\n"
		""},
	 { "DiscreteGraphicalModel_idFromName", _wrap_DiscreteGraphicalModel_idFromName, METH_VARARGS, "\n"
		"\n"
		"Return the node id of a variable given its name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the name of the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the node id of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if no variable with this name exists in the model\n"
		"\n"
		""},
	 { "DiscreteGraphicalModel_variableFromName", _wrap_DiscreteGraphicalModel_variableFromName, METH_VARARGS, "\n"
		"\n"
		"Return the variable with the given name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the name of the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiscreteVariable\n"
		"    the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if no variable with this name exists in the model\n"
		"\n"
		""},
	 { "DiscreteGraphicalModel_swigregister", DiscreteGraphicalModel_swigregister, METH_O, NULL},
	 { "delete_DAGmodel", _wrap_delete_DAGmodel, METH_O, NULL},
	 { "new_DAGmodel", _wrap_new_DAGmodel, METH_VARARGS, 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\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\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\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 of 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 of str|int\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|list of str|int\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|list of 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_connectedComponents", _wrap_DAGmodel_connectedComponents, METH_O, "\n"
		"\n"
		"Return the weakly connected components of the graph.\n"
		"\n"
		"Each node is mapped to the id of its component root (an arbitrarily chosen node from the same component).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict[int, int]\n"
		"    mapping node id → component root id\n"
		"\n"
		"See Also\n"
		"--------\n"
		"connectedComponentsList : returns a dict[int, set[int]] grouping nodes by component\n"
		"connectedComponentsCount : returns the number of components\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, "\n"
		"\n"
		"Return a minimal conditioning set of a target node (or set of nodes) given a set of source nodes in the DAG model.\n"
		"\n"
		"A minimal conditioning set is a subset of the source nodes that d-separates the targets from the remaining sources.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int | str | list[int|str]\n"
		"    the target node id(s) or name(s)\n"
		"soids : list[int|str]\n"
		"    the list of source node ids or names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set[int]\n"
		"    the minimal conditioning set (as node ids)\n"
		"\n"
		""},
	 { "DAGmodel_swigregister", DAGmodel_swigregister, METH_O, NULL},
	 { "DAGmodel_swiginit", DAGmodel_swiginit, METH_VARARGS, NULL},
	 { "delete_UGmodel", _wrap_delete_UGmodel, METH_O, NULL},
	 { "new_UGmodel", _wrap_new_UGmodel, METH_VARARGS, NULL},
	 { "UGmodel_graph", _wrap_UGmodel_graph, METH_O, "\n"
		"\n"
		"Return the underlying undirected graph.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.UndiGraph\n"
		"    the underlying graph\n"
		"\n"
		""},
	 { "UGmodel_size", _wrap_UGmodel_size, METH_O, "\n"
		"\n"
		"Return the number of nodes (variables) in the graphical model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of nodes\n"
		"\n"
		""},
	 { "UGmodel_sizeEdges", _wrap_UGmodel_sizeEdges, METH_O, "\n"
		"\n"
		"Return the number of edges in the model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of edges\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Check whether an edge exists between two nodes.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n1 : int | str\n"
		"    one endpoint (id or name)\n"
		"n2 : int | str\n"
		"    the other endpoint (id or name)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the edge exists\n"
		"\n"
		""},
	 { "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 of str|int\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|list of str|int\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|list of 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, "\n"
		"\n"
		"Check whether this model has the same undirected structure as another UGmodel.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"other : pyagrum.MarkovRandomField\n"
		"    the model to compare with\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the undirected structures are identical\n"
		"\n"
		""},
	 { "UGmodel_connectedComponents", _wrap_UGmodel_connectedComponents, METH_O, "\n"
		"\n"
		"Return the connected components of the undirected model.\n"
		"\n"
		"Each node is mapped to the id of its component root.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict[int, int]\n"
		"    mapping node id → component root id\n"
		"\n"
		""},
	 { "UGmodel_family", _wrap_UGmodel_family, METH_VARARGS, "\n"
		"\n"
		"Return the family of a node: the node itself plus all its neighbours.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the node id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set[int]\n"
		"    the node and all its neighbours\n"
		"\n"
		""},
	 { "UGmodel_swigregister", UGmodel_swigregister, METH_O, NULL},
	 { "UGmodel_swiginit", UGmodel_swiginit, METH_VARARGS, 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"
		""},
	 { "fastDiGraph", _wrap_fastDiGraph, METH_O, "\n"
		"\n"
		"Build a graph from a dot-like syntax : ``'A->B->C;B->E'``.\n"
		"\n"
		"``'->'`` denotes a directed arc, ``'<-'`` a directed arc in the other direction\n"
		"(e.g. ``'A->B<-C'`` means both A and C point to B), ``'-'`` an undirected edge,\n"
		"``';'`` separates independent chains. If every node token in the description is\n"
		"a non-negative integer, those integers are used directly as node ids ;\n"
		"otherwise every token -- including numeric-looking ones -- is used as a node\n"
		"name.\n"
		"\n"
		"Note\n"
		"----\n"
		"A single ``'-'`` (not ``'--'``) is used for edges on purpose : ``pyagrum.fastMRF``\n"
		"already uses ``'--'`` to list the variables of a single factor (a clique), a\n"
		"different construct from a chain of pairwise edges. ``'A--B'`` is therefore\n"
		"rejected here rather than silently misread.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArc\n"
		"  If the description requires a directed arc but the target graph type does\n"
		"  not support arcs, or if the description is malformed.\n"
		"gum.InvalidEdge\n"
		"  If the description requires an undirected edge but the target graph type\n"
		"  does not support edges.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"desc : str\n"
		"  the string containing the dot-like specification\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiGraph or pyagrum.UndiGraph or pyagrum.MixedGraph or pyagrum.DAG or pyagrum.PDAG\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> gum.fastDiGraph('A->B->C;B->E')\n"
		">>> gum.fastUndiGraph('A-B-C')\n"
		">>> gum.fastMixedGraph('A->B-C')\n"
		">>> gum.fastDAG('A->B->C')\n"
		">>> gum.fastPDAG('A->B-C')\n"
		"\n"
		""},
	 { "fastUndiGraph", _wrap_fastUndiGraph, METH_O, "\n"
		"\n"
		"Build a graph from a dot-like syntax : ``'A->B->C;B->E'``.\n"
		"\n"
		"``'->'`` denotes a directed arc, ``'<-'`` a directed arc in the other direction\n"
		"(e.g. ``'A->B<-C'`` means both A and C point to B), ``'-'`` an undirected edge,\n"
		"``';'`` separates independent chains. If every node token in the description is\n"
		"a non-negative integer, those integers are used directly as node ids ;\n"
		"otherwise every token -- including numeric-looking ones -- is used as a node\n"
		"name.\n"
		"\n"
		"Note\n"
		"----\n"
		"A single ``'-'`` (not ``'--'``) is used for edges on purpose : ``pyagrum.fastMRF``\n"
		"already uses ``'--'`` to list the variables of a single factor (a clique), a\n"
		"different construct from a chain of pairwise edges. ``'A--B'`` is therefore\n"
		"rejected here rather than silently misread.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArc\n"
		"  If the description requires a directed arc but the target graph type does\n"
		"  not support arcs, or if the description is malformed.\n"
		"gum.InvalidEdge\n"
		"  If the description requires an undirected edge but the target graph type\n"
		"  does not support edges.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"desc : str\n"
		"  the string containing the dot-like specification\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiGraph or pyagrum.UndiGraph or pyagrum.MixedGraph or pyagrum.DAG or pyagrum.PDAG\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> gum.fastDiGraph('A->B->C;B->E')\n"
		">>> gum.fastUndiGraph('A-B-C')\n"
		">>> gum.fastMixedGraph('A->B-C')\n"
		">>> gum.fastDAG('A->B->C')\n"
		">>> gum.fastPDAG('A->B-C')\n"
		"\n"
		""},
	 { "fastMixedGraph", _wrap_fastMixedGraph, METH_O, "\n"
		"\n"
		"Build a graph from a dot-like syntax : ``'A->B->C;B->E'``.\n"
		"\n"
		"``'->'`` denotes a directed arc, ``'<-'`` a directed arc in the other direction\n"
		"(e.g. ``'A->B<-C'`` means both A and C point to B), ``'-'`` an undirected edge,\n"
		"``';'`` separates independent chains. If every node token in the description is\n"
		"a non-negative integer, those integers are used directly as node ids ;\n"
		"otherwise every token -- including numeric-looking ones -- is used as a node\n"
		"name.\n"
		"\n"
		"Note\n"
		"----\n"
		"A single ``'-'`` (not ``'--'``) is used for edges on purpose : ``pyagrum.fastMRF``\n"
		"already uses ``'--'`` to list the variables of a single factor (a clique), a\n"
		"different construct from a chain of pairwise edges. ``'A--B'`` is therefore\n"
		"rejected here rather than silently misread.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArc\n"
		"  If the description requires a directed arc but the target graph type does\n"
		"  not support arcs, or if the description is malformed.\n"
		"gum.InvalidEdge\n"
		"  If the description requires an undirected edge but the target graph type\n"
		"  does not support edges.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"desc : str\n"
		"  the string containing the dot-like specification\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiGraph or pyagrum.UndiGraph or pyagrum.MixedGraph or pyagrum.DAG or pyagrum.PDAG\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> gum.fastDiGraph('A->B->C;B->E')\n"
		">>> gum.fastUndiGraph('A-B-C')\n"
		">>> gum.fastMixedGraph('A->B-C')\n"
		">>> gum.fastDAG('A->B->C')\n"
		">>> gum.fastPDAG('A->B-C')\n"
		"\n"
		""},
	 { "fastDAG", _wrap_fastDAG, METH_O, "\n"
		"\n"
		"Build a graph from a dot-like syntax : ``'A->B->C;B->E'``.\n"
		"\n"
		"``'->'`` denotes a directed arc, ``'<-'`` a directed arc in the other direction\n"
		"(e.g. ``'A->B<-C'`` means both A and C point to B), ``'-'`` an undirected edge,\n"
		"``';'`` separates independent chains. If every node token in the description is\n"
		"a non-negative integer, those integers are used directly as node ids ;\n"
		"otherwise every token -- including numeric-looking ones -- is used as a node\n"
		"name.\n"
		"\n"
		"Note\n"
		"----\n"
		"A single ``'-'`` (not ``'--'``) is used for edges on purpose : ``pyagrum.fastMRF``\n"
		"already uses ``'--'`` to list the variables of a single factor (a clique), a\n"
		"different construct from a chain of pairwise edges. ``'A--B'`` is therefore\n"
		"rejected here rather than silently misread.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArc\n"
		"  If the description requires a directed arc but the target graph type does\n"
		"  not support arcs, or if the description is malformed.\n"
		"gum.InvalidEdge\n"
		"  If the description requires an undirected edge but the target graph type\n"
		"  does not support edges.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"desc : str\n"
		"  the string containing the dot-like specification\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiGraph or pyagrum.UndiGraph or pyagrum.MixedGraph or pyagrum.DAG or pyagrum.PDAG\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> gum.fastDiGraph('A->B->C;B->E')\n"
		">>> gum.fastUndiGraph('A-B-C')\n"
		">>> gum.fastMixedGraph('A->B-C')\n"
		">>> gum.fastDAG('A->B->C')\n"
		">>> gum.fastPDAG('A->B-C')\n"
		"\n"
		""},
	 { "fastPDAG", _wrap_fastPDAG, METH_O, "\n"
		"\n"
		"Build a graph from a dot-like syntax : ``'A->B->C;B->E'``.\n"
		"\n"
		"``'->'`` denotes a directed arc, ``'<-'`` a directed arc in the other direction\n"
		"(e.g. ``'A->B<-C'`` means both A and C point to B), ``'-'`` an undirected edge,\n"
		"``';'`` separates independent chains. If every node token in the description is\n"
		"a non-negative integer, those integers are used directly as node ids ;\n"
		"otherwise every token -- including numeric-looking ones -- is used as a node\n"
		"name.\n"
		"\n"
		"Note\n"
		"----\n"
		"A single ``'-'`` (not ``'--'``) is used for edges on purpose : ``pyagrum.fastMRF``\n"
		"already uses ``'--'`` to list the variables of a single factor (a clique), a\n"
		"different construct from a chain of pairwise edges. ``'A--B'`` is therefore\n"
		"rejected here rather than silently misread.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArc\n"
		"  If the description requires a directed arc but the target graph type does\n"
		"  not support arcs, or if the description is malformed.\n"
		"gum.InvalidEdge\n"
		"  If the description requires an undirected edge but the target graph type\n"
		"  does not support edges.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"desc : str\n"
		"  the string containing the dot-like specification\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiGraph or pyagrum.UndiGraph or pyagrum.MixedGraph or pyagrum.DAG or pyagrum.PDAG\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> gum.fastDiGraph('A->B->C;B->E')\n"
		">>> gum.fastUndiGraph('A-B-C')\n"
		">>> gum.fastMixedGraph('A->B-C')\n"
		">>> gum.fastDAG('A->B->C')\n"
		">>> gum.fastPDAG('A->B-C')\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: NumericalDiscreteVariable, 4: RangeVariable\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 label at the given index\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"
		"index : int\n"
		"    an index\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the numerical representation of the value at the given index\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 index 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 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"
		"val : 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 gum.LabelizedVariable).\n"
		"\n"
		""},
	 { "DiscretizedVariable_toFast", _wrap_DiscretizedVariable_toFast, METH_O, "\n"
		"\n"
		"Return the variable description in fast syntax (e.g. ``name[v1:v2:v3]``).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    fast-syntax string representation\n"
		"\n"
		""},
	 { "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_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, "\n"
		"\n"
		"Create a uniform tensor over a single discrete variable (all values equal to 1/domainSize).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyagrum.DiscreteVariable\n"
		"    the variable defining the domain\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tensor\n"
		"    uniform tensor over var\n"
		"\n"
		""},
	 { "new_Tensor", _wrap_new_Tensor, METH_VARARGS, NULL},
	 { "delete_Tensor", _wrap_delete_Tensor, METH_O, NULL},
	 { "Tensor_random", _wrap_Tensor_random, METH_O, "\n"
		"\n"
		"Fill the tensor with random values uniformly drawn from [0,1].\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tensor\n"
		"    self (in-place modification)\n"
		"\n"
		""},
	 { "Tensor_randomDistribution", _wrap_Tensor_randomDistribution, METH_O, "\n"
		"\n"
		"Fill the tensor as a random probability distribution (values are non-negative and sum to 1).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tensor\n"
		"    self (in-place modification)\n"
		"\n"
		""},
	 { "Tensor_randomCPT", _wrap_Tensor_randomCPT, METH_O, "\n"
		"\n"
		"Fill the tensor as a random conditional probability table (each conditional distribution sums to 1).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tensor\n"
		"    self (in-place modification)\n"
		"\n"
		""},
	 { "Tensor_noising", _wrap_Tensor_noising, METH_VARARGS, "\n"
		"\n"
		"Add noise to a CPT by mixing it with a random CPT: ``(1 - alpha) * self + alpha * randomCPT()``.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"alpha : float\n"
		"    noise level, must be in [0, 1]\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tensor\n"
		"    self (in-place modification)\n"
		"\n"
		""},
	 { "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_mean", _wrap_Tensor_mean, METH_O, "\n"
		"\n"
		"Compute the mean of a univariate numerical discrete distribution.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.ArgumentError\n"
		"  If the tensor is not a 1-dimensional distribution (sum != 1) or if the variable is not numerical.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the mean of the distribution\n"
		"\n"
		""},
	 { "Tensor_variance", _wrap_Tensor_variance, METH_O, "\n"
		"\n"
		"Compute the variance of a univariate numerical discrete distribution.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.ArgumentError\n"
		"  If the tensor is not a 1-dimensional distribution (sum != 1) or if the variable is not numerical.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the variance of the distribution\n"
		"\n"
		""},
	 { "Tensor_stdDev", _wrap_Tensor_stdDev, METH_O, "\n"
		"\n"
		"Compute the standard deviation of a univariate numerical discrete distribution.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.ArgumentError\n"
		"  If the tensor is not a 1-dimensional distribution (sum != 1) or if the variable is not numerical.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  the standard deviation of the distribution\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 or numpy.ndarray\n"
		"    a value or a list/pyagrum.Tensor/ndarray containing the values to fill the Tensor with.\n"
		"\n"
		"mapping : list|tuple|dict\n"
		"\n"
		"Warnings\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"
		"    - if `v` is a ``numpy.ndarray``, it must be C-contiguous, dtype ``float64``, and its total size must equal the domain size. If it is N-D, its shape must equal ``tuple(reversed(self.shape))``. Copies the data in a single ``memcpy``.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"      a reference to the modified tensor\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"
		"Warnings\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, "\n"
		"\n"
		"Apply the sign function element-wise in place: -1 if value < 0, 0 if value == 0, 1 if value > 0.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tensor\n"
		"    self (in-place modification)\n"
		"\n"
		""},
	 { "Tensor_new_abs", _wrap_Tensor_new_abs, METH_O, "\n"
		"\n"
		"Return a new tensor with the absolute value applied to each element.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tensor\n"
		"    new tensor\n"
		"\n"
		""},
	 { "Tensor_new_sq", _wrap_Tensor_new_sq, METH_O, "\n"
		"\n"
		"Return a new tensor with each element squared.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tensor\n"
		"    new tensor\n"
		"\n"
		""},
	 { "Tensor_new_log2", _wrap_Tensor_new_log2, METH_O, "\n"
		"\n"
		"Return a new tensor with the base-2 logarithm applied to each element.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tensor\n"
		"    new tensor\n"
		"\n"
		""},
	 { "Tensor_new_sgn", _wrap_Tensor_new_sgn, METH_O, "\n"
		"\n"
		"Return a new tensor with the sign function applied element-wise: -1 if value < 0, 0 if value == 0, 1 if value > 0.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tensor\n"
		"    new tensor\n"
		"\n"
		""},
	 { "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 `p`.\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, "\n"
		"\n"
		"Invert each value of the tensor in place (replace x by 1/x for each element).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tensor\n"
		"    self (in-place modification)\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Check whether the tensor represents a likelihood (soft evidence) over a single variable.\n"
		"\n"
		"A tensor is an evidence if it has exactly one variable, all values are in [0, 1], and the sum is positive.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the tensor is a valid likelihood vector\n"
		"\n"
		""},
	 { "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"
		"Notes\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"
		"Notes\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"
		"Notes\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"
		"Notes\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)->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\n"
		"  a dictionnary containing values for some discrete variables.\n"
		"\n"
		"Warnings\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\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\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__as_nparray_raw", _wrap_Tensor__as_nparray_raw, METH_VARARGS, NULL},
	 { "Tensor__toarray_raw", _wrap_Tensor__toarray_raw, METH_O, NULL},
	 { "Tensor__fillWithNpArray", _wrap_Tensor__fillWithNpArray, 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"
		"int\n"
		"    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"
		"Check whether a variable is in the tensor.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyagrum.DiscreteVariable\n"
		"    the variable to check.\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 variable 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"
		"pyagrum.DuplicateElement\n"
		"  If the variable is already in this Tensor.\n"
		"pyagrum.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, "\n"
		"\n"
		"Print debug statistics on aGrUM objects.\n"
		"\n"
		"Only active in debug build mode (GUM_DEBUG_MODE). No output in release mode.\n"
		"\n"
		""},
	 { "getNumberOfThreads", _wrap_getNumberOfThreads, METH_NOARGS, "\n"
		"\n"
		"Return the current number of threads used in parallel regions.\n"
		"\n"
		"This is equal to getMaxNumberOfThreads() unless the user has called setNumberOfThreads().\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the current thread count for parallel regions\n"
		"\n"
		""},
	 { "getMaxNumberOfThreads", _wrap_getMaxNumberOfThreads, METH_NOARGS, "\n"
		"\n"
		"Return the maximum number of threads available (equal to the number of logical processors by default).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the maximum number of threads\n"
		"\n"
		""},
	 { "getNumberOfLogicalProcessors", _wrap_getNumberOfLogicalProcessors, METH_NOARGS, "\n"
		"\n"
		"Return the number of logical processors available on the system.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of logical processors\n"
		"\n"
		""},
	 { "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"
		"Notes\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, "\n"
		"\n"
		"Callback called when a node is added to the Bayesian network.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the id of the new node\n"
		"name : str\n"
		"    the name of the new node\n"
		"\n"
		""},
	 { "PythonBNListener_whenNodeDeleted", _wrap_PythonBNListener_whenNodeDeleted, METH_VARARGS, "\n"
		"\n"
		"Callback called when a node is removed from the Bayesian network.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the id of the deleted node\n"
		"\n"
		""},
	 { "PythonBNListener_whenArcAdded", _wrap_PythonBNListener_whenArcAdded, METH_VARARGS, "\n"
		"\n"
		"Callback called when an arc is added to the Bayesian network.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"src : int\n"
		"    the tail node id\n"
		"dst : int\n"
		"    the head node id\n"
		"\n"
		""},
	 { "PythonBNListener_whenArcDeleted", _wrap_PythonBNListener_whenArcDeleted, METH_VARARGS, "\n"
		"\n"
		"Callback called when an arc is removed from the Bayesian network.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"src : int\n"
		"    the tail node id\n"
		"dst : int\n"
		"    the head node id\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Callback invoked during loading to report progress.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"filename : str\n"
		"    the file being loaded\n"
		"pct : int\n"
		"    the current loading progress percentage\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Callback invoked at each iteration step of the approximation algorithm.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pct : float\n"
		"    the current progress percentage\n"
		"error : float\n"
		"    the current error estimate\n"
		"time : float\n"
		"    the elapsed time\n"
		"\n"
		""},
	 { "PythonApproximationListener_whenStop", _wrap_PythonApproximationListener_whenStop, METH_VARARGS, "\n"
		"\n"
		"Callback invoked when the approximation algorithm stops.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message : str\n"
		"    a message describing the stopping reason\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Callback invoked at each progress step during database generation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"src : object\n"
		"    the source of the notification\n"
		"step : int\n"
		"    the current progress step\n"
		"duration : float\n"
		"    elapsed time in seconds\n"
		"\n"
		""},
	 { "PythonDatabaseGeneratorListener_whenStop", _wrap_PythonDatabaseGeneratorListener_whenStop, METH_VARARGS, "\n"
		"\n"
		"Callback invoked when the database generation stops.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"src : object\n"
		"    the source of the notification\n"
		"message : str\n"
		"    a message describing the stop condition\n"
		"\n"
		""},
	 { "PythonDatabaseGeneratorListener_setWhenProgress", _wrap_PythonDatabaseGeneratorListener_setWhenProgress, METH_VARARGS, "\n"
		"\n"
		"Register a callback called at each progress step.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pyfunc : callable\n"
		"    a function called with (step: int, duration: float) at each progress notification\n"
		"\n"
		""},
	 { "PythonDatabaseGeneratorListener_setWhenStop", _wrap_PythonDatabaseGeneratorListener_setWhenStop, METH_VARARGS, "\n"
		"\n"
		"Register a callback called when the generation stops.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pyfunc : callable\n"
		"    a function called with (message: str) when the generation is done\n"
		"\n"
		""},
	 { "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"
		"      .. 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, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  float\n"
		"    The mutual information between nodeset X and nodeset Y\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the conditional entropy of nodeset (X ∪ Y) conditioned by nodeset Z\n"
		"\n"
		""},
	 { "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 pyagrum.Tensor (like a pyagrum.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, "\n"
		"\n"
		"Return the skeleton of the essential graph (the underlying undirected graph without arc orientations).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.UndiGraph\n"
		"    the skeleton of the essential graph\n"
		"\n"
		""},
	 { "EssentialGraph_connectedComponents", _wrap_EssentialGraph_connectedComponents, METH_O, "\n"
		"\n"
		"Return the connected components of the essential graph.\n"
		"\n"
		"Each node is mapped to the id of its component root (an arbitrarily chosen node from the same component).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict[int, int]\n"
		"    mapping node id → component root id\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Return the set of node ids in the essential graph.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set[int]\n"
		"    the set of all node ids\n"
		"\n"
		""},
	 { "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_descendants", _wrap_EssentialGraph_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\n"
		"  the set of ids of the descendants of node `norid`.\n"
		"\n"
		""},
	 { "EssentialGraph_ancestors", _wrap_EssentialGraph_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\n"
		"  the set of ids of the ancestors of node `norid`.\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_descendants", _wrap_MarkovBlanket_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\n"
		"  the set of ids of the descendants of node `norid`.\n"
		"\n"
		""},
	 { "MarkovBlanket_ancestors", _wrap_MarkovBlanket_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\n"
		"  the set of ids of the ancestors of node `norid`.\n"
		"\n"
		""},
	 { "MarkovBlanket_swigregister", MarkovBlanket_swigregister, METH_O, NULL},
	 { "MarkovBlanket_swiginit", MarkovBlanket_swiginit, METH_VARARGS, NULL},
	 { "new_StructuralMetrics", _wrap_new_StructuralMetrics, METH_NOARGS, NULL},
	 { "delete_StructuralMetrics", _wrap_delete_StructuralMetrics, METH_O, NULL},
	 { "StructuralMetrics_tp_skeleton", _wrap_StructuralMetrics_tp_skeleton, METH_O, "\n"
		"\n"
		"Number of true positives at the skeleton level (undirected edges correctly\n"
		"predicted, ignoring orientation).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    True-positive count for the skeleton.\n"
		"\n"
		""},
	 { "StructuralMetrics_fp_skeleton", _wrap_StructuralMetrics_fp_skeleton, METH_O, "\n"
		"\n"
		"Number of false positives at the skeleton level (extra undirected edges in\n"
		"the test skeleton).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    False-positive count for the skeleton.\n"
		"\n"
		""},
	 { "StructuralMetrics_fn_skeleton", _wrap_StructuralMetrics_fn_skeleton, METH_O, "\n"
		"\n"
		"Number of false negatives at the skeleton level (undirected edges present in\n"
		"the ref skeleton but missing from the test skeleton).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    False-negative count for the skeleton.\n"
		"\n"
		""},
	 { "StructuralMetrics_tn_skeleton", _wrap_StructuralMetrics_tn_skeleton, METH_O, "\n"
		"\n"
		"Number of true negatives at the skeleton level (pairs correctly absent from\n"
		"both ref and test skeletons).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    True-negative count for the skeleton.\n"
		"\n"
		""},
	 { "StructuralMetrics_precision_skeleton", _wrap_StructuralMetrics_precision_skeleton, METH_O, "\n"
		"\n"
		"Precision at the skeleton level: TP / (TP + FP).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    Skeleton precision in [0, 1].\n"
		"\n"
		""},
	 { "StructuralMetrics_recall_skeleton", _wrap_StructuralMetrics_recall_skeleton, METH_O, "\n"
		"\n"
		"Recall at the skeleton level: TP / (TP + FN).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    Skeleton recall in [0, 1].\n"
		"\n"
		""},
	 { "StructuralMetrics_f_score_skeleton", _wrap_StructuralMetrics_f_score_skeleton, METH_O, "\n"
		"\n"
		"F1-score at the skeleton level: harmonic mean of skeleton precision and recall.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    Skeleton F1-score in [0, 1].\n"
		"\n"
		""},
	 { "StructuralMetrics_shd_skeleton", _wrap_StructuralMetrics_shd_skeleton, METH_O, "\n"
		"\n"
		"Structural Hamming Distance at the skeleton level: number of edge insertions\n"
		"and deletions needed to transform the test skeleton into the ref skeleton.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    Skeleton SHD (non-negative integer returned as float).\n"
		"\n"
		""},
	 { "StructuralMetrics_tp", _wrap_StructuralMetrics_tp, METH_O, "\n"
		"\n"
		"Number of true positives at the arc/edge level (correctly predicted arcs or\n"
		"edges, orientation included for directed graphs).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    True-positive count.\n"
		"\n"
		""},
	 { "StructuralMetrics_fp", _wrap_StructuralMetrics_fp, METH_O, "\n"
		"\n"
		"Number of false positives at the arc/edge level (extra or misoriented arcs/edges\n"
		"in the test graph).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    False-positive count.\n"
		"\n"
		""},
	 { "StructuralMetrics_fn", _wrap_StructuralMetrics_fn, METH_O, "\n"
		"\n"
		"Number of false negatives at the arc/edge level (arcs/edges present in ref but\n"
		"missing from test).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    False-negative count.\n"
		"\n"
		""},
	 { "StructuralMetrics_tn", _wrap_StructuralMetrics_tn, METH_O, "\n"
		"\n"
		"Number of true negatives at the arc/edge level (pairs correctly absent from\n"
		"both ref and test).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    True-negative count.\n"
		"\n"
		""},
	 { "StructuralMetrics_precision", _wrap_StructuralMetrics_precision, METH_O, "\n"
		"\n"
		"Precision at the arc/edge level (orientation included): TP / (TP + FP).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    Precision in [0, 1].\n"
		"\n"
		""},
	 { "StructuralMetrics_recall", _wrap_StructuralMetrics_recall, METH_O, "\n"
		"\n"
		"Recall at the arc/edge level (orientation included): TP / (TP + FN).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    Recall in [0, 1].\n"
		"\n"
		""},
	 { "StructuralMetrics_f_score", _wrap_StructuralMetrics_f_score, METH_O, "\n"
		"\n"
		"F1-score at the arc/edge level: harmonic mean of precision and recall.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    F1-score in [0, 1].\n"
		"\n"
		""},
	 { "StructuralMetrics_shd", _wrap_StructuralMetrics_shd, METH_O, "\n"
		"\n"
		"Structural Hamming Distance: number of arc/edge insertions, deletions and\n"
		"reversals needed to transform the test graph into the ref graph.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    SHD (non-negative integer returned as float).\n"
		"\n"
		""},
	 { "StructuralMetrics_compare", _wrap_StructuralMetrics_compare, METH_VARARGS, "\n"
		"\n"
		"Compare two graphs of the same type and equal size, populating the internal\n"
		"confusion matrix used by all metric accessors.\n"
		"\n"
		"The following overloads are available:\n"
		"\n"
		"* ``compare(DiGraph, DiGraph)`` — nodes matched by NodeId (no alignment).\n"
		"* ``compare(UndiGraph, UndiGraph)`` — nodes matched by NodeId (no alignment).\n"
		"* ``compare(PDAG, PDAG)`` — nodes matched by NodeId (no alignment).\n"
		"* ``compare(BayesNet, BayesNet)`` — nodes matched by variable name; comparison\n"
		"  runs on the corresponding essential graphs (CPDAGs).\n"
		"* ``compare(BayesNet, PDAG)`` — ref BN is converted to its essential graph first.\n"
		"* ``compare(PDAG, BayesNet)`` — test BN is converted to its essential graph first.\n"
		"\n"
		"For a DAG-level comparison of two BayesNets, align NodeIds manually (e.g. by\n"
		"building an aligned BN by variable name) and call ``compare(DiGraph, DiGraph)``\n"
		"with ``bn.dag()``. SID (see :meth:`sid`) is the only metric that natively\n"
		"operates on the DAGs of BayesNets.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"ref :\n"
		"    Reference graph (DiGraph, UndiGraph, PDAG, or BayesNet).\n"
		"test :\n"
		"    Graph to evaluate against the reference (same type as ref, or PDAG when\n"
		"    ref is a BayesNet and vice-versa).\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If both graphs are empty, or if their sizes differ.\n"
		"pyagrum.InvalidNode\n"
		"    If a node present in ref is absent from test (for BayesNet overloads,\n"
		"    matching is done by variable name).\n"
		"\n"
		""},
	 { "StructuralMetrics_sid", _wrap_StructuralMetrics_sid, METH_VARARGS, "\n"
		"\n"
		"Compute the Structural Intervention Distance (SID) between two DAGs\n"
		"(Peters & Bühlmann, 2015).\n"
		"\n"
		"SID counts the number of ordered pairs (i, j) for which the\n"
		"parent-adjustment set for the causal effect of i on j in the reference graph\n"
		"is incorrectly reproduced by the test graph.\n"
		"\n"
		"Properties:\n"
		"\n"
		"* ``sid(G, G) == 0``\n"
		"* If G ⊆ H (all parents of G are parents of H), then ``sid(G, H) == 0``.\n"
		"* SID is asymmetric: ``sid(G, H) != sid(H, G)`` in general.\n"
		"\n"
		"Two overloads are available:\n"
		"\n"
		"* ``sid(DAG, DAG)`` — operates directly on DAG objects.\n"
		"* ``sid(BayesNet, BayesNet)`` — nodes matched by variable name; the comparison\n"
		"  runs on the underlying DAGs after name-based alignment.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"ref :\n"
		"    Reference DAG or BayesNet.\n"
		"test :\n"
		"    DAG or BayesNet to evaluate against the reference.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    The SID value (non-negative integer returned as float).\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If the graphs have different sizes.\n"
		"pyagrum.InvalidNode\n"
		"    If a variable present in ref is absent from test (BayesNet overload only).\n"
		"\n"
		""},
	 { "StructuralMetrics_swigregister", StructuralMetrics_swigregister, METH_O, NULL},
	 { "StructuralMetrics_swiginit", StructuralMetrics_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_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 of str\n"
		"  list of found issues\n"
		"\n"
		""},
	 { "IBayesNet___eq__", _wrap_IBayesNet___eq__, 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 (pyagrum.DiscretizedVariable with a large number of ticks) that the variable is equal to a given value.\n"
		"\n"
		"Notes\n"
		"-----\n"
		"  - see also Tensor.evEq\n"
		"  - see also BayesNet.evGt, BayesNet.evLt, 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 : 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 pyagrum.Tensor.\n"
		"\n"
		""},
	 { "IBayesNet_evIn", _wrap_IBayesNet_evIn, METH_VARARGS, "\n"
		"\n"
		"This method is used to set an observation on a quasi-continuous variables (pyagrum.DiscretizedVariable with a large number of ticks) that the variable is in a given range.\n"
		"\n"
		"Notes\n"
		"-----\n"
		"  - see also Tensor.evIn\n"
		"  - see also BayesNet.evEq, BayesNet.evGt, BayesNet.evLt\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : 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 pyagrum.Tensor.\n"
		"\n"
		""},
	 { "IBayesNet_evLt", _wrap_IBayesNet_evLt, METH_VARARGS, "\n"
		"\n"
		"This method is used to set an observation on a quasi-continuous variables (pyagrum.DiscretizedVariable with a large number of ticks) that the variable is less than a given value.\n"
		"\n"
		"Notes\n"
		"-----\n"
		"  - see also Tensor.evLt\n"
		"  - see also BayesNet.evEq, BayesNet.evGt, BayesNet.evIn\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : 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 pyagrum.Tensor.\n"
		"\n"
		""},
	 { "IBayesNet_evGt", _wrap_IBayesNet_evGt, METH_VARARGS, "\n"
		"\n"
		"This method is used to set an observation on a quasi-continuous variables (pyagrum.DiscretizedVariable with a large number of ticks) that the variable is greater than a given value.\n"
		"\n"
		"Notes\n"
		"-----\n"
		"  - see also Tensor.evGt\n"
		"  - see also BayesNet.evEq, BayesNet.evLt, 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.evGt('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 : 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 pyagrum.Tensor.\n"
		"\n"
		""},
	 { "IBayesNet_memoryFootprint", _wrap_IBayesNet_memoryFootprint, METH_O, "\n"
		"\n"
		"Returns the memory footprint in bytes of the Bayesian network.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the memory footprint in bytes of the Bayesian network\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 of str\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list of 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 of str\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\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 of int\n"
		"    The ids of the targets\n"
		"list : list of int\n"
		"    The list of available variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\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 of str|int\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|list of str|int\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|list of 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\n"
		"    The names of the graph variables\n"
		"\n"
		""},
	 { "IBayesNet_nodes", _wrap_IBayesNet_nodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\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\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\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\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 of 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"
		"Notes\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 :  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_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 fast syntax)\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 pyagrum.BayesNet.\n"
		"\n"
		"Removes the corresponding variable from the pyagrum.BayesNet and from all of it's children pyagrum.Tensor.\n"
		"\n"
		"If no variable matches the given id, then nothing is done.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int | str | pyagrum.DiscreteVariable\n"
		"    the current name, the id of the variable or a reference to the variable\n"
		"\n"
		""},
	 { "BayesNet_changeVariableName", _wrap_BayesNet_changeVariableName, METH_VARARGS, "\n"
		"\n"
		"Changes a variable's name in the pyagrum.BayesNet.\n"
		"\n"
		"This will change the pyagrum.DiscreteVariable names in the pyagrum.BayesNet.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : 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 : 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_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 : int | str\n"
		"    a variable's id (int) or name\n"
		"tail : 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 : int | str\n"
		"    a variable's id (int) or name for the head when calling eraseArc(head,tail)\n"
		"tail : 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 exist 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 : int | str\n"
		"    a variable's id (int) or name\n"
		"tail : 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 : 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 : 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_idFromName", _wrap_BayesNet_idFromName, METH_VARARGS, "\n"
		"\n"
		"Return the node id of a variable given its name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the name of the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the node id of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if no variable with this name exists in the model\n"
		"\n"
		""},
	 { "BayesNet_variableNodeMap", _wrap_BayesNet_variableNodeMap, METH_O, "\n"
		"\n"
		"Return the variable-to-node mapping of the model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.VariableNodeMap\n"
		"    the internal variable-to-node bijection\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_nodeId", _wrap_BayesNet_nodeId, METH_VARARGS, "\n"
		"\n"
		"Return the node id of a variable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyagrum.DiscreteVariable\n"
		"    the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the node id of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if the variable does not exist in the model\n"
		"\n"
		""},
	 { "BayesNet_variableFromName", _wrap_BayesNet_variableFromName, METH_VARARGS, "\n"
		"\n"
		"Return the variable with the given name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the name of the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiscreteVariable\n"
		"    the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if no variable with this name exists in the model\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 of str\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list of 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 of str\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\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 of int\n"
		"    The ids of the targets\n"
		"list : list of int\n"
		"    The list of available variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\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 of str|int\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|list of str|int\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|list of 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\n"
		"    The names of the graph variables\n"
		"\n"
		""},
	 { "BayesNet_nodes", _wrap_BayesNet_nodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\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\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\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\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 of 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_loadGUM", _wrap_BayesNet_loadGUM, METH_VARARGS, "\n"
		"\n"
		"Load a jgum (JSON) or bgum (binary/msgpack) file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the file's path (extension: ``.jgum`` for JSON, ``.bgum`` for binary)\n"
		"binary : bool\n"
		"    if True, read as bgum (msgpack) regardless of extension (default: False)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.IOError\n"
		"    If file not found\n"
		"pyagrum.FatalError\n"
		"    If file content is not valid\n"
		"\n"
		"See Also\n"
		"--------\n"
		":ref:`jgum-bgum-format` : complete format reference\n"
		"\n"
		""},
	 { "BayesNet__saveGUM", _wrap_BayesNet__saveGUM, METH_VARARGS, "\n"
		"\n"
		"Save the BayesNet in a jgum (JSON) or bgum (binary/msgpack) file.\n"
		"\n"
		"Metadata properties (``software``, ``creation``, ``lastModification``) are updated automatically.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the file's path\n"
		"binary : bool\n"
		"    if True, write as bgum (msgpack); otherwise write as jgum (JSON) (default: False)\n"
		"indent : int\n"
		"    indentation level for JSON output; -1 for compact, 2 for pretty-printed (default: 2)\n"
		"\n"
		"See Also\n"
		"--------\n"
		":ref:`jgum-bgum-format` : complete format reference\n"
		"\n"
		""},
	 { "BayesNet__saveGUMstring", _wrap_BayesNet__saveGUMstring, METH_VARARGS, "\n"
		"\n"
		"Serialize the BayesNet to a jgum JSON string.\n"
		"\n"
		"Metadata properties (``software``, ``creation``, ``lastModification``) are updated automatically.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"indent : int\n"
		"    indentation level; -1 for compact, 2 for pretty-printed (default: 2)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a JSON string representing the BayesNet in jgum format\n"
		"\n"
		"See Also\n"
		"--------\n"
		":ref:`jgum-bgum-format` : complete format reference\n"
		"\n"
		""},
	 { "BayesNet_loadGUMstring", _wrap_BayesNet_loadGUMstring, METH_VARARGS, "\n"
		"\n"
		"Deserialize a BayesNet from a jgum JSON string.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"content : str\n"
		"    a JSON string in jgum format\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.FatalError\n"
		"    If the string is not valid jgum JSON or the type field does not match ``\"BN\"``\n"
		"\n"
		"See Also\n"
		"--------\n"
		":ref:`jgum-bgum-format` : complete format reference\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, "\n"
		"\n"
		"Return a new Bayesian network conditioned on observations and interventions.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"observations : dict\n"
		"    a dict mapping variable names (str) or ids (int) to observed values (str or int)\n"
		"interventions : dict\n"
		"    a dict mapping variable names (str) or ids (int) to intervened values (str or int)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BayesNet\n"
		"    a new BayesNet representing the interventional/observational distribution\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"    if arguments are not dicts\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Internal callback invoked when a node is added to the referenced BayesNet.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"src : object\n"
		"    the event source\n"
		"id : int\n"
		"    the id of the new node\n"
		"\n"
		""},
	 { "BayesNetFragment_whenNodeDeleted", _wrap_BayesNetFragment_whenNodeDeleted, METH_VARARGS, "\n"
		"\n"
		"Internal callback invoked when a node is removed from the referenced BayesNet.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"src : object\n"
		"    the event source\n"
		"id : int\n"
		"    the id of the deleted node\n"
		"\n"
		""},
	 { "BayesNetFragment_whenArcAdded", _wrap_BayesNetFragment_whenArcAdded, METH_VARARGS, "\n"
		"\n"
		"Internal callback invoked when an arc is added to the referenced BayesNet.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"src : object\n"
		"    the event source\n"
		"from : int\n"
		"    the tail node id\n"
		"to : int\n"
		"    the head node id\n"
		"\n"
		""},
	 { "BayesNetFragment_whenArcDeleted", _wrap_BayesNetFragment_whenArcDeleted, METH_VARARGS, "\n"
		"\n"
		"Internal callback invoked when an arc is removed from the referenced BayesNet.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"src : object\n"
		"    the event source\n"
		"from : int\n"
		"    the tail node id\n"
		"to : int\n"
		"    the head node id\n"
		"\n"
		""},
	 { "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 : 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 of str\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list of 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 of str\n"
		"  List of variable names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\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 of int\n"
		"    The ids of the targets\n"
		"list : list of int\n"
		"    The list of available variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\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 of str|int\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|list of str|int\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|list of 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\n"
		"    The names of the graph variables\n"
		"\n"
		""},
	 { "BayesNetFragment_nodes", _wrap_BayesNetFragment_nodes, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\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\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\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\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 of 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, "\n"
		"\n"
		"Replace the triangulation algorithm used to build the junction tree.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"new_triangulation : pyagrum.Triangulation\n"
		"    the new triangulation algorithm\n"
		"\n"
		""},
	 { "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\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 of 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, "\n"
		"\n"
		"Compute the joint mutual information (interaction information) among a set of target variables.\n"
		"\n"
		"See https://en.wikipedia.org/wiki/Interaction_information\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"targets : list[str] or set[int]\n"
		"    the target variables (names or node ids)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the joint mutual information\n"
		"\n"
		""},
	 { "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 of int|str\n"
		"  a list of node Ids or node names\n"
		"evs : set\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, "\n"
		"\n"
		"Replace the triangulation algorithm used to build the junction tree.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"new_triangulation : pyagrum.Triangulation\n"
		"    the new triangulation algorithm\n"
		"\n"
		""},
	 { "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 of 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, "\n"
		"\n"
		"Compute the joint mutual information (interaction information) among a set of target variables.\n"
		"\n"
		"See https://en.wikipedia.org/wiki/Interaction_information\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"targets : list[str] or set[int]\n"
		"    the target variables (names or node ids)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the joint mutual information\n"
		"\n"
		""},
	 { "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 of int|str\n"
		"  a list of node Ids or node names\n"
		"evs : set\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, "\n"
		"\n"
		"Replace the triangulation algorithm used to build the junction tree.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"new_triangulation : pyagrum.Triangulation\n"
		"    the new triangulation algorithm\n"
		"\n"
		""},
	 { "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 of 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, "\n"
		"\n"
		"Compute the joint mutual information (interaction information) among a set of target variables.\n"
		"\n"
		"See https://en.wikipedia.org/wiki/Interaction_information\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"targets : list[str] or set[int]\n"
		"    the target variables (names or node ids)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the joint mutual information\n"
		"\n"
		""},
	 { "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 of int|str\n"
		"  a list of node Ids or node names\n"
		"evs : set\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 of 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 of 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 of 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 of 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, "\n"
		"\n"
		"Internal implementation of the loopy sampling inference.\n"
		"\n"
		"This protected virtual method performs the actual sampling-based inference loop.\n"
		"\n"
		""},
	 { "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 of 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, "\n"
		"\n"
		"Internal implementation of the loopy sampling inference.\n"
		"\n"
		"This protected virtual method performs the actual sampling-based inference loop.\n"
		"\n"
		""},
	 { "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 of 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, "\n"
		"\n"
		"Internal implementation of the loopy sampling inference.\n"
		"\n"
		"This protected virtual method performs the actual sampling-based inference loop.\n"
		"\n"
		""},
	 { "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 of 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, "\n"
		"\n"
		"Internal implementation of the loopy sampling inference.\n"
		"\n"
		"This protected virtual method performs the actual sampling-based inference loop.\n"
		"\n"
		""},
	 { "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 of 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 of 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\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\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_MCBNDistance", _wrap_new_MCBNDistance, METH_VARARGS, NULL},
	 { "delete_MCBNDistance", _wrap_delete_MCBNDistance, METH_O, NULL},
	 { "MCBNDistance_compute", _wrap_MCBNDistance_compute, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict\n"
		"    a dictionnary containing the different values after the computation.\n"
		"\n"
		""},
	 { "MCBNDistance_setVerbosity", _wrap_MCBNDistance_setVerbosity, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "MCBNDistance_setEpsilon", _wrap_MCBNDistance_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"
		""},
	 { "MCBNDistance_setMinEpsilonRate", _wrap_MCBNDistance_setMinEpsilonRate, METH_VARARGS, "\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : float\n"
		"    the minimal epsilon rate\n"
		"\n"
		""},
	 { "MCBNDistance_setMaxIter", _wrap_MCBNDistance_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"
		""},
	 { "MCBNDistance_setMaxTime", _wrap_MCBNDistance_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"
		""},
	 { "MCBNDistance_setPeriodSize", _wrap_MCBNDistance_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"
		""},
	 { "MCBNDistance_verbosity", _wrap_MCBNDistance_verbosity, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the verbosity is enabled\n"
		"\n"
		""},
	 { "MCBNDistance_epsilon", _wrap_MCBNDistance_epsilon, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the value of epsilon\n"
		"\n"
		""},
	 { "MCBNDistance_minEpsilonRate", _wrap_MCBNDistance_minEpsilonRate, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "MCBNDistance_maxIter", _wrap_MCBNDistance_maxIter, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the criterion on number of iterations\n"
		"\n"
		""},
	 { "MCBNDistance_maxTime", _wrap_MCBNDistance_maxTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the timeout(in seconds)\n"
		"\n"
		""},
	 { "MCBNDistance_periodSize", _wrap_MCBNDistance_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"
		""},
	 { "MCBNDistance_nbrIterations", _wrap_MCBNDistance_nbrIterations, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of iterations\n"
		"\n"
		""},
	 { "MCBNDistance_currentTime", _wrap_MCBNDistance_currentTime, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    get the current running time in second (float)\n"
		"\n"
		""},
	 { "MCBNDistance_messageApproximationScheme", _wrap_MCBNDistance_messageApproximationScheme, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    the approximation scheme message\n"
		"\n"
		""},
	 { "MCBNDistance_history", _wrap_MCBNDistance_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"
		""},
	 { "MCBNDistance__asIApproximationSchemeConfiguration", _wrap_MCBNDistance__asIApproximationSchemeConfiguration, METH_O, NULL},
	 { "MCBNDistance_swigregister", MCBNDistance_swigregister, METH_O, NULL},
	 { "MCBNDistance_swiginit", MCBNDistance_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 of 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\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\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 : pyagrum.Instantiation or dict\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"
		"Warnings\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"
		"Warnings\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"
		"learner : pyagrum.BNLearner\n"
		"    the BNLearner to copy state from.\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, "\n"
		"\n"
		"Set the period size for the EM stopping criterion check.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"    number of iterations between two stopping criterion evaluations (must be ≥ 1)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OutOfBounds\n"
		"    if p < 1\n"
		"\n"
		""},
	 { "BNLearner_EMPeriodSize", _wrap_BNLearner_EMPeriodSize, METH_O, "\n"
		"\n"
		"Return the period size used by the EM stopping criterion check.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    number of EM iterations between two stopping criterion evaluations\n"
		"\n"
		""},
	 { "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. This algorithm\n"
		"exploits all the three operators arc addition, arc deletion and arc reversal\n"
		"and only these operators.\n"
		"\n"
		""},
	 { "BNLearner_useExtendedGreedyHillClimbing", _wrap_BNLearner_useExtendedGreedyHillClimbing, METH_O, "\n"
		"\n"
		"Indicate that we wish to use a greedy hill climbing algorithm, controlling the\n"
		"set of arc operations that this learning algorithm is allowed to exploit.\n"
		"Those are the traditional arc additions, arc deletions and arc reversals, plus\n"
		"two additional operators arc triangle deletion1 and arc triangle deletion2\n"
		"that are capable of transforming triangles into v-structures. To control which\n"
		"operations are allowed, see Methods allowArcAdditions, allowArcDeletions,\n"
		"allowArcReversals, allowArcTriangleDeletions.\n"
		"\n"
		""},
	 { "BNLearner_useGreedyThickThinning", _wrap_BNLearner_useGreedyThickThinning, METH_O, "\n"
		"\n"
		"Indicate that we wish to use the greedy thick-thinning algorithm.\n"
		"\n"
		"This two-phase algorithm first greedily adds arcs (thick phase) until no\n"
		"addition improves the score, then greedily removes arcs (thin phase) until no\n"
		"deletion improves the score. By default the thin phase uses only arc deletions;\n"
		"arc reversals can optionally be allowed via setGreedyThickThinningReversals.\n"
		"\n"
		""},
	 { "BNLearner_setGreedyThickThinningReversals", _wrap_BNLearner_setGreedyThickThinningReversals, METH_VARARGS, "\n"
		"\n"
		"Enable or disable arc reversals during the thin phase of greedy thick-thinning.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"allow : bool\n"
		"    If True, arc reversals are considered in addition to arc deletions during\n"
		"    the thin phase (default: False).\n"
		"\n"
		""},
	 { "BNLearner_greedyThickThinningReversals", _wrap_BNLearner_greedyThickThinningReversals, METH_O, "\n"
		"\n"
		"Returns whether arc reversals are allowed in the thin phase of greedy thick-thinning.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if arc reversals are enabled in the thin phase, False otherwise.\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_usePC", _wrap_BNLearner_usePC, METH_O, "\n"
		"\n"
		"Indicate that we wish to use the PC (Peter-Clark) algorithm.\n"
		"\n"
		"PC is a constraint-based structure learning algorithm. It learns a CPDAG\n"
		"(completed partially directed acyclic graph) from data via conditional\n"
		"independence tests. Three phases: skeleton discovery, v-structure orientation,\n"
		"and Meek rules propagation.\n"
		"\n"
		"After calling `usePC()`, configure the independence test with `useChi2Test()`\n"
		"(default) or `useG2Test()`, and optionally tune the significance threshold with\n"
		"`setPCAlpha()`.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"    the BNLearner itself, to allow method chaining.\n"
		"\n"
		""},
	 { "BNLearner_useFCI", _wrap_BNLearner_useFCI, METH_O, "\n"
		"\n"
		"Indicate that we wish to use the FCI (Fast Causal Inference) algorithm.\n"
		"\n"
		"FCI is a constraint-based structure learning algorithm that, unlike PC, handles\n"
		"latent confounders and selection bias. It learns a PAG (Partial Ancestral Graph)\n"
		"from data via conditional independence tests. Use `learnPAG()` to retrieve the result.\n"
		"\n"
		"After calling `useFCI()`, configure the independence test with `useFCIChi2Test()`\n"
		"(default) or `useFCIG2Test()`, and tune the significance threshold with `setFCIAlpha()`.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"    the BNLearner itself, to allow method chaining.\n"
		"\n"
		""},
	 { "BNLearner_useFCIChi2Test", _wrap_BNLearner_useFCIChi2Test, METH_O, "\n"
		"\n"
		"Select the chi-squared (χ²) independence test for the FCI algorithm.\n"
		"\n"
		"This is the default test when `useFCI()` is called.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"    the BNLearner itself, to allow method chaining.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If FCI has not been selected (call `useFCI()` first).\n"
		"\n"
		""},
	 { "BNLearner_useFCIG2Test", _wrap_BNLearner_useFCIG2Test, METH_O, "\n"
		"\n"
		"Select the G² (log-likelihood ratio) independence test for the FCI algorithm.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"    the BNLearner itself, to allow method chaining.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If FCI has not been selected (call `useFCI()` first).\n"
		"\n"
		""},
	 { "BNLearner_setFCIAlpha", _wrap_BNLearner_setFCIAlpha, METH_VARARGS, "\n"
		"\n"
		"Set the significance threshold (alpha) for independence tests used by FCI.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"alpha : float\n"
		"    significance level in (0, 1). Lower values produce sparser graphs.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"    the BNLearner itself, to allow method chaining.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If FCI has not been selected (call `useFCI()` first).\n"
		"\n"
		""},
	 { "BNLearner_setFCIMaxPathLength", _wrap_BNLearner_setFCIMaxPathLength, METH_VARARGS, "\n"
		"\n"
		"Set the maximum conditioning set size for independence tests used by FCI.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max_len : int\n"
		"    maximum path length (conditioning set size). Use -1 for unlimited.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"    the BNLearner itself, to allow method chaining.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If FCI has not been selected (call `useFCI()` first).\n"
		"\n"
		""},
	 { "BNLearner_setFCIExhaustiveSepSet", _wrap_BNLearner_setFCIExhaustiveSepSet, METH_VARARGS, "\n"
		"\n"
		"Enable or disable exhaustive separating-set mode for the FCI skeleton phase.\n"
		"\n"
		"In standard mode (default, ``False``) FCI stops at the first separating set found\n"
		"for each pair of nodes at each conditioning depth. In exhaustive mode (``True``) it\n"
		"tests all subsets of that depth and stores the *union* of all separating sets found.\n"
		"A wider separating set suppresses more collider orientations (conservative), at the\n"
		"cost of more independence tests.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"exhaustive : bool\n"
		"    ``True`` to enable exhaustive mode, ``False`` to restore standard mode.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"    the BNLearner itself, to allow method chaining.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If FCI has not been selected (call `useFCI()` first).\n"
		"\n"
		""},
	 { "BNLearner_fciExhaustiveSepSet", _wrap_BNLearner_fciExhaustiveSepSet, METH_O, "\n"
		"\n"
		"Return whether FCI exhaustive separating-set mode is enabled.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    ``True`` if exhaustive sepset mode is on, ``False`` otherwise (default).\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If FCI has not been selected (call `useFCI()` first).\n"
		"\n"
		""},
	 { "BNLearner_useChi2Test", _wrap_BNLearner_useChi2Test, METH_O, "\n"
		"\n"
		"Select the chi-squared (χ²) independence test for the PC algorithm.\n"
		"\n"
		"This is the default test when `usePC()` is called. The test measures\n"
		"whether two variables are conditionally independent given a set of\n"
		"conditioning variables by comparing observed and expected counts under\n"
		"the independence hypothesis.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"    the BNLearner itself, to allow method chaining.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If the PC algorithm has not been selected (call `usePC()` first).\n"
		"\n"
		""},
	 { "BNLearner_useG2Test", _wrap_BNLearner_useG2Test, METH_O, "\n"
		"\n"
		"Select the G² (log-likelihood ratio) independence test for the PC algorithm.\n"
		"\n"
		"G² is an alternative to χ² based on the likelihood-ratio statistic.\n"
		"It is asymptotically equivalent to χ² but may perform better on sparse\n"
		"contingency tables.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"    the BNLearner itself, to allow method chaining.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If the PC algorithm has not been selected (call `usePC()` first).\n"
		"\n"
		""},
	 { "BNLearner_setPCAlpha", _wrap_BNLearner_setPCAlpha, METH_VARARGS, "\n"
		"\n"
		"Set the significance threshold (α) used by the PC algorithm to decide\n"
		"whether two variables are conditionally independent.\n"
		"\n"
		"An edge (X, Y) is removed from the skeleton when the p-value of the\n"
		"conditional independence test exceeds α. Smaller α makes PC more\n"
		"conservative (fewer edges removed); larger α makes it more aggressive.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"alpha : float\n"
		"    significance threshold in (0, 1). Default is 0.05.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"    the BNLearner itself, to allow method chaining.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If the PC algorithm has not been selected (call `usePC()` first).\n"
		"\n"
		""},
	 { "BNLearner_setPCStable", _wrap_BNLearner_setPCStable, METH_VARARGS, "\n"
		"\n"
		"Set whether to use the stable variant of the PC algorithm.\n"
		"\n"
		"In stable PC (default), the adjacency sets used to build conditioning\n"
		"subsets are frozen at the start of each depth level and edge removals\n"
		"are deferred until the end of that level. This makes the result\n"
		"order-independent within each depth level.\n"
		"\n"
		"In unstable PC (`stable=False`), edges are removed immediately and\n"
		"adjacency sets are updated on the fly, which may cause the result to\n"
		"depend on the order in which edges are processed.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"stable : bool\n"
		"    True (default) for stable PC, False for the original (unstable) PC.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"    the BNLearner itself, to allow method chaining.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If the PC algorithm has not been selected (call `usePC()` first).\n"
		"\n"
		""},
	 { "BNLearner_setPCMaxCondSetSize", _wrap_BNLearner_setPCMaxCondSetSize, METH_VARARGS, "\n"
		"\n"
		"Set the maximum size of conditioning sets considered by the PC algorithm.\n"
		"\n"
		"PC tests conditional independence of X and Y given subsets S of the\n"
		"neighbours of X (or Y). By default all subset sizes are considered\n"
		"(unlimited). Setting a limit k restricts tests to :math:`|S| \\leq k`, which\n"
		"reduces runtime at the cost of possibly missing some independencies.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max_k : int\n"
		"    maximum conditioning set size. Pass a very large integer (or leave\n"
		"    unset) for no limit.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"    the BNLearner itself, to allow method chaining.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If the PC algorithm has not been selected (call `usePC()` first).\n"
		"\n"
		""},
	 { "BNLearner_setPCUnshieldedColliderSorted", _wrap_BNLearner_setPCUnshieldedColliderSorted, METH_VARARGS, "\n"
		"\n"
		"Set the ordering strategy used when orienting unshielded colliders in the PC algorithm.\n"
		"\n"
		"When ``sorted=True``, triples are processed in descending order of the p-value\n"
		"of the separating set test (strongest evidence of collider first). This can\n"
		"reduce orientation conflicts and improve reproducibility.\n"
		"\n"
		"When ``sorted=False`` (default), triples are processed in natural traversal order.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sorted : bool\n"
		"    True to process unshielded colliders by descending p-value; False for natural order.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"    the BNLearner itself, to allow method chaining.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If the PC algorithm has not been selected (call ``usePC()`` first).\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_setTotalOrder", _wrap_BNLearner_setTotalOrder, METH_VARARGS, "\n"
		"\n"
		"Sets a total order on a set of nodes (not necessarily all the nodes). In the\n"
		"case where only a proper subset of all the nodes is passed in argument, then\n"
		"the constraint applies only on the arcs for which both extremal nodes belong\n"
		"to the set.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"l : list\n"
		"        a list of row ids or strings (variable names)\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, any 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_allowArcAdditions", _wrap_BNLearner_allowArcAdditions, METH_VARARGS, "\n"
		"\n"
		"Sets whether ExtendedGreedyHillClimbing and LocalSearchWithTabuList are\n"
		"allowed to perform arc addition operations or not.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"allow : bool\n"
		"    arc additions allowed if and only if allow is equal to true\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"    the BNLearner itself, so that we can chain useXXX() and allowXXX() methods.\n"
		"\n"
		""},
	 { "BNLearner_allowArcDeletions", _wrap_BNLearner_allowArcDeletions, METH_VARARGS, "\n"
		"\n"
		"Sets whether ExtendedGreedyHillClimbing and LocalSearchWithTabuList are\n"
		"allowed to perform arc deletion operations or not.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"allow : bool\n"
		"    arc deletions allowed if and only if allow is equal to true\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() and allowXXX() methods.\n"
		"\n"
		""},
	 { "BNLearner_allowArcReversals", _wrap_BNLearner_allowArcReversals, METH_VARARGS, "\n"
		"\n"
		"Sets whether ExtendedGreedyHillClimbing and LocalSearchWithTabuList are\n"
		"allowed to perform arc reveral operations (changing the direction of the arc) or not.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"allow : bool\n"
		"    arc reversals allowed if and only if allow is equal to true\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() and allowXXX() methods.\n"
		"\n"
		""},
	 { "BNLearner_allowArcTriangleDeletions", _wrap_BNLearner_allowArcTriangleDeletions, METH_VARARGS, "\n"
		"\n"
		"Sets whether ExtendedGreedyHillClimbing and LocalSearchWithTabuList are\n"
		"allowed to perform arc triangle deletion operations or not. Arc triangle deletions\n"
		"consist of substituting triangles (node1 -> node2 -> node3 + node1 -> node3) into\n"
		"v-structures node2 -> node1 <- node3 or node1 -> node2 <- node3.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"allow : bool\n"
		"    arc triangle deletions allowed if and only if allow is equal to true\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BNLearner\n"
		"        the BNLearner itself, so that we can chain useXXX() and allowXXX() methods.\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_learnPAG", _wrap_BNLearner_learnPAG, METH_O, "\n"
		"\n"
		"Learn a Partial Ancestral Graph (PAG) from the BNLearner's database using FCI.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.PAG\n"
		"    the learned PAG\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If `useFCI()` has not been called first.\n"
		"\n"
		"See Also\n"
		"--------\n"
		"useFCI, setFCIAlpha, setFCIMaxPathLength\n"
		"\n"
		""},
	 { "BNLearner_names", _wrap_BNLearner_names, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\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 : int\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 of str\n"
		"        the name of the columns of interest\n"
		"\n"
		"knowing : list of 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 of 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 of 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 of str\n"
		"        the list of names of conditioning columns\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\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 of int|str\n"
		"        the list of variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list of 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"
		"int\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 of 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, "\n"
		"\n"
		"Returns an int representing the state of the EM algorithm.\n"
		"\n"
		"The possible states are:\n"
		"  0. Undefined\n"
		"  1. Continue: EM has not been stopped yet\n"
		"  2. Epsilon: EM has been stopped due to the min log-likelihood difference stopping criterion\n"
		"  3. Rate: EM has been stopped due to the min log-likelihood evolution rate stopping criterion\n"
		"  4. Limit: EM has been stopped due to a limit on the number of iterations\n"
		"  5. TimeLimit: EM has been stopped due to a timeout\n"
		"  6. Stopped: EM has been stopped because there was a divergence on the log-likelihood\n"
		"\n"
		""},
	 { "BNLearner_EMStateMessage", _wrap_BNLearner_EMStateMessage, METH_O, "\n"
		"\n"
		"Return a human-readable message describing the current state of the EM algorithm.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    state message (same information as EMStateApproximationScheme but as text)\n"
		"\n"
		""},
	 { "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 of str\n"
		"        the list of the column names of the conditioning variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\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 of str\n"
		"        the list of the column names of the conditioning variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\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"
		"Returns the list of latent variables discovered by MIIC.\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\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\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"
		"Warnings\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"
		"Warnings\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"
		"Warnings\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, "\n"
		"\n"
		"Used with binary networks to speed-up L2U inference.\n"
		"\n"
		"Store the lower and upper probabilities of each node X over the 'True' modality.\n"
		"\n"
		""},
	 { "CredalNet_src_bn", _wrap_CredalNet_src_bn, METH_O, "\n"
		"\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, "\n"
		"\n"
		"Check whether the binary CPT min/max values have been computed.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if binary CPT min/max have been computed (via the dedicated computation method)\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Add evidence for a variable in the credal network.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id_or_name : int | str\n"
		"    the node id or name\n"
		"val_or_label : int | str\n"
		"    the value index or label for the evidence\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_CN", _wrap_CNMonteCarloSampling_CN, METH_O, "\n"
		"\n"
		"Return the credal network used by this inference engine.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CredalNet\n"
		"    the credal network\n"
		"\n"
		""},
	 { "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_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_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_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, "\n"
		"\n"
		"Add evidence for a variable in the credal network.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id_or_name : int | str\n"
		"    the node id or name\n"
		"val_or_label : int | str\n"
		"    the value index or label for the evidence\n"
		"\n"
		""},
	 { "CNLoopyPropagation_CN", _wrap_CNLoopyPropagation_CN, METH_O, "\n"
		"\n"
		"Return the credal network used by this inference engine.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CredalNet\n"
		"    the credal network\n"
		"\n"
		""},
	 { "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"
		"Notes\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_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, "\n"
		"\n"
		"Clear the influence diagram, removing all nodes and arcs.\n"
		"\n"
		""},
	 { "InfluenceDiagram_cpt", _wrap_InfluenceDiagram_cpt, METH_VARARGS, "\n"
		"\n"
		"Returns the CPT of a variable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : 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 : 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_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 :  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 : 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 : int | str\n"
		"    a variable's id (int) or name\n"
		"head : 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 : int | str\n"
		"    a variable's id (int) or name when calling eraseArc(tail,head)\n"
		"head : 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, "\n"
		"\n"
		"Return the sequence of decision nodes in a valid decision order.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list[int]\n"
		"    the ordered list of decision node ids\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if no valid decision order exists\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Begin a sequence of structural modifications to the influence diagram.\n"
		"\n"
		"Structural changes are batched until endTopologyTransformation is called.\n"
		"\n"
		""},
	 { "InfluenceDiagram_endTopologyTransformation", _wrap_InfluenceDiagram_endTopologyTransformation, METH_O, "\n"
		"\n"
		"End a sequence of structural modifications and recompute internal structures.\n"
		"\n"
		"Should be called after beginTopologyTransformation when all modifications are done.\n"
		"\n"
		""},
	 { "InfluenceDiagram_idFromName", _wrap_InfluenceDiagram_idFromName, METH_VARARGS, "\n"
		"\n"
		"Return the node id of a variable given its name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the name of the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the node id of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if no variable with this name exists in the model\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"
		"Return the node id of a variable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyagrum.DiscreteVariable\n"
		"    the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the node id of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if the variable does not exist in the model\n"
		"\n"
		""},
	 { "InfluenceDiagram_variableFromName", _wrap_InfluenceDiagram_variableFromName, METH_VARARGS, "\n"
		"\n"
		"Return the variable with the given name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the name of the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiscreteVariable\n"
		"    the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if no variable with this name exists in the model\n"
		"\n"
		""},
	 { "InfluenceDiagram_names", _wrap_InfluenceDiagram_names, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list of 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 : 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 : 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\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\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\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 of 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_loadGUM", _wrap_InfluenceDiagram_loadGUM, METH_VARARGS, "\n"
		"\n"
		"Load a jgum (JSON) or bgum (binary/msgpack) file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the file's path (extension: ``.jgum`` for JSON, ``.bgum`` for binary)\n"
		"binary : bool\n"
		"    if True, read as bgum (msgpack) regardless of extension (default: False)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.IOError\n"
		"    If file not found\n"
		"pyagrum.FatalError\n"
		"    If file content is not valid\n"
		"\n"
		"See Also\n"
		"--------\n"
		":ref:`jgum-bgum-format` : complete format reference\n"
		"\n"
		""},
	 { "InfluenceDiagram__saveGUM", _wrap_InfluenceDiagram__saveGUM, METH_VARARGS, "\n"
		"\n"
		"Save the InfluenceDiagram in a jgum (JSON) or bgum (binary/msgpack) file.\n"
		"\n"
		"Metadata properties (``software``, ``creation``, ``lastModification``) are updated automatically.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the file's path\n"
		"binary : bool\n"
		"    if True, write as bgum (msgpack); otherwise write as jgum (JSON) (default: False)\n"
		"indent : int\n"
		"    indentation level for JSON output; -1 for compact, 2 for pretty-printed (default: 2)\n"
		"\n"
		"See Also\n"
		"--------\n"
		":ref:`jgum-bgum-format` : complete format reference\n"
		"\n"
		""},
	 { "InfluenceDiagram__saveGUMstring", _wrap_InfluenceDiagram__saveGUMstring, METH_VARARGS, "\n"
		"\n"
		"Serialize the InfluenceDiagram to a jgum JSON string.\n"
		"\n"
		"Metadata properties (``software``, ``creation``, ``lastModification``) are updated automatically.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"indent : int\n"
		"    indentation level; -1 for compact, 2 for pretty-printed (default: 2)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a JSON string representing the InfluenceDiagram in jgum format\n"
		"\n"
		"See Also\n"
		"--------\n"
		":ref:`jgum-bgum-format` : complete format reference\n"
		"\n"
		""},
	 { "InfluenceDiagram_loadGUMstring", _wrap_InfluenceDiagram_loadGUMstring, METH_VARARGS, "\n"
		"\n"
		"Deserialize an InfluenceDiagram from a jgum JSON string.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"content : str\n"
		"    a JSON string in jgum format\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.FatalError\n"
		"    If the string is not valid jgum JSON or the type field does not match ``\"ID\"``\n"
		"\n"
		"See Also\n"
		"--------\n"
		":ref:`jgum-bgum-format` : complete format reference\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, "\n"
		"\n"
		"Clear all evidence and reset the inference engine to its initial state.\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_addNoForgettingAssumption", _wrap_ShaferShenoyLIMIDInference_addNoForgettingAssumption, METH_VARARGS, "\n"
		"\n"
		"Add a no-forgetting assumption for a list of decision variables.\n"
		"\n"
		"The no-forgetting assumption means that each decision node has access to all variables observed before it in the decision order.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"ids : list[int]\n"
		"    the list of decision node ids\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.InvalidArgument\n"
		"    if a given id is not a decision node\n"
		"\n"
		""},
	 { "ShaferShenoyLIMIDInference_hasNoForgettingAssumption", _wrap_ShaferShenoyLIMIDInference_hasNoForgettingAssumption, METH_O, "\n"
		"\n"
		"Check whether the no-forgetting assumption has been added.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the no-forgetting assumption is currently active\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Return the reversed partial order of decision nodes used internally.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list[set[int]]\n"
		"    the reversed partial order as a list of node id sets\n"
		"\n"
		""},
	 { "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 of 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, "\n"
		"\n"
		"Return the set of nodes with soft (likelihood) evidence.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set[int]\n"
		"    the set of node ids with soft evidence\n"
		"\n"
		""},
	 { "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___eq__", _wrap_IMarkovRandomField___eq__, METH_VARARGS, NULL},
	 { "IMarkovRandomField_dim", _wrap_IMarkovRandomField_dim, METH_O, "\n"
		"\n"
		"Return the dimension (total number of free parameters) of the Markov random field.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of free parameters\n"
		"\n"
		""},
	 { "IMarkovRandomField_maxVarDomainSize", _wrap_IMarkovRandomField_maxVarDomainSize, METH_O, "\n"
		"\n"
		"Return the maximum domain size among all variables in the model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the maximum domain size\n"
		"\n"
		""},
	 { "IMarkovRandomField_minParam", _wrap_IMarkovRandomField_minParam, METH_O, "\n"
		"\n"
		"Return the minimum parameter value across all factors.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the minimum factor parameter\n"
		"\n"
		""},
	 { "IMarkovRandomField_maxParam", _wrap_IMarkovRandomField_maxParam, METH_O, "\n"
		"\n"
		"Return the maximum parameter value across all factors.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the maximum factor parameter\n"
		"\n"
		""},
	 { "IMarkovRandomField_minNonZeroParam", _wrap_IMarkovRandomField_minNonZeroParam, METH_O, "\n"
		"\n"
		"Return the minimum non-zero parameter value across all factors.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the minimum non-zero factor parameter\n"
		"\n"
		""},
	 { "IMarkovRandomField_maxNonOneParam", _wrap_IMarkovRandomField_maxNonOneParam, METH_O, "\n"
		"\n"
		"Return the maximum parameter value strictly less than 1 across all factors.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the maximum non-one factor parameter\n"
		"\n"
		""},
	 { "IMarkovRandomField_toDot", _wrap_IMarkovRandomField_toDot, METH_O, "\n"
		"\n"
		"Return a Graphviz dot representation of the Markov random field.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a dot-format string\n"
		"\n"
		""},
	 { "IMarkovRandomField_toDotAsFactorGraph", _wrap_IMarkovRandomField_toDotAsFactorGraph, METH_O, "\n"
		"\n"
		"Return a Graphviz dot representation of the Markov random field as a factor graph.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a dot-format string with variable nodes and factor nodes\n"
		"\n"
		""},
	 { "IMarkovRandomField_names", _wrap_IMarkovRandomField_names, METH_O, "\n"
		"\n"
		"Set of names of variables in the model\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\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 of str|int\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|list of str|int\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|list of 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, "\n"
		"\n"
		"Create a Markov random field from a Bayesian network.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"bn : pyagrum.BayesNet\n"
		"    the Bayesian network to convert\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.MarkovRandomField\n"
		"    a new MRF with the same variables and moralised structure\n"
		"\n"
		""},
	 { "delete_MarkovRandomField", _wrap_delete_MarkovRandomField, METH_O, NULL},
	 { "new_MarkovRandomField", _wrap_new_MarkovRandomField, METH_VARARGS, NULL},
	 { "MarkovRandomField_smallestFactorFromNode", _wrap_MarkovRandomField_smallestFactorFromNode, METH_VARARGS, "\n"
		"\n"
		"Return the id set of the smallest factor that contains the given node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node : int\n"
		"    the node id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set[int]\n"
		"    the id set of the smallest factor containing this node\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if no factor contains this node\n"
		"\n"
		""},
	 { "MarkovRandomField_factors", _wrap_MarkovRandomField_factors, METH_O, "\n"
		"\n"
		"Return the table of all factors in the Markov random field.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict\n"
		"    a dict mapping frozenset[int] (node id sets) to pyagrum.Tensor\n"
		"\n"
		""},
	 { "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 pyagrum.MarkovRandomField.\n"
		"\n"
		"Removes the corresponding variable from the pyagrum.MarkovRandomField and from all of it's children pyagrum.Tensor.\n"
		"\n"
		"If no variable matches the given id, then nothing is done.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var :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_changeVariableName", _wrap_MarkovRandomField_changeVariableName, METH_VARARGS, "\n"
		"\n"
		"Changes a variable's name in the pyagrum.MarkovRandomField.\n"
		"\n"
		"This will change the pyagrum.DiscreteVariable names in the pyagrum.MarkovRandomField.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"car :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 :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_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 : int | str\n"
		"    a variable's id (int) or name\n"
		"\n"
		""},
	 { "MarkovRandomField_beginTopologyTransformation", _wrap_MarkovRandomField_beginTopologyTransformation, METH_O, "\n"
		"\n"
		"Begin a sequence of structural modifications (factor additions/deletions).\n"
		"\n"
		"Structural changes are batched until endTopologyTransformation is called, which then adjusts all factor dimensions.\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Return the underlying undirected graph.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.UndiGraph\n"
		"    the underlying graph\n"
		"\n"
		""},
	 { "MarkovRandomField_size", _wrap_MarkovRandomField_size, METH_O, "\n"
		"\n"
		"Return the number of nodes (variables) in the graphical model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of nodes\n"
		"\n"
		""},
	 { "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_idFromName", _wrap_MarkovRandomField_idFromName, METH_VARARGS, "\n"
		"\n"
		"Return the node id of a variable given its name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the name of the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the node id of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if no variable with this name exists in the model\n"
		"\n"
		""},
	 { "MarkovRandomField_variableNodeMap", _wrap_MarkovRandomField_variableNodeMap, METH_O, "\n"
		"\n"
		"Return the variable-to-node mapping of the model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.VariableNodeMap\n"
		"    the internal variable-to-node bijection\n"
		"\n"
		""},
	 { "MarkovRandomField_variable", _wrap_MarkovRandomField_variable, METH_VARARGS, "\n"
		"\n"
		"Return the variable associated with a given node id.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the node id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiscreteVariable\n"
		"    the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if the node id does not exist\n"
		"\n"
		""},
	 { "MarkovRandomField_nodeId", _wrap_MarkovRandomField_nodeId, METH_VARARGS, "\n"
		"\n"
		"Return the node id of a variable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyagrum.DiscreteVariable\n"
		"    the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the node id of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if the variable does not exist in the model\n"
		"\n"
		""},
	 { "MarkovRandomField_variableFromName", _wrap_MarkovRandomField_variableFromName, METH_VARARGS, "\n"
		"\n"
		"Return the variable with the given name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the name of the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiscreteVariable\n"
		"    the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if no variable with this name exists in the model\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\n"
		"    The names of the graph variables\n"
		"\n"
		""},
	 { "MarkovRandomField_nodes", _wrap_MarkovRandomField_nodes, METH_O, "\n"
		"\n"
		"Return the set of node ids in the model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set[int]\n"
		"    the set of node ids\n"
		"\n"
		""},
	 { "MarkovRandomField_neighbours", _wrap_MarkovRandomField_neighbours, METH_VARARGS, "\n"
		"\n"
		"Return the set of neighbours of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the node id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set[int]\n"
		"    the set of neighbour node ids\n"
		"\n"
		""},
	 { "MarkovRandomField_edges", _wrap_MarkovRandomField_edges, METH_O, "\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of edges in the Markov random field\n"
		"\n"
		""},
	 { "MarkovRandomField_minimalCondSet", _wrap_MarkovRandomField_minimalCondSet, METH_VARARGS, "\n"
		"\n"
		"Return a minimal conditioning set of a target given source nodes in the MRF.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int | str | list[int|str]\n"
		"    the target node id(s) or name(s)\n"
		"soids : list[int|str]\n"
		"    the list of source node ids or names\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set[int]\n"
		"    the minimal conditioning set (as node ids)\n"
		"\n"
		""},
	 { "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 : set\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 of str|int\n"
		"      a list of of nodeIds or names\n"
		"Y : str|int|list of str|int\n"
		"      a list of of nodeIds or names\n"
		"Z : str|int|list of 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_loadGUM", _wrap_MarkovRandomField_loadGUM, METH_VARARGS, "\n"
		"\n"
		"Load a jgum (JSON) or bgum (binary/msgpack) file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the file's path (extension: ``.jgum`` for JSON, ``.bgum`` for binary)\n"
		"binary : bool\n"
		"    if True, read as bgum (msgpack) regardless of extension (default: False)\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.IOError\n"
		"    If file not found\n"
		"pyagrum.FatalError\n"
		"    If file content is not valid\n"
		"\n"
		"See Also\n"
		"--------\n"
		":ref:`jgum-bgum-format` : complete format reference\n"
		"\n"
		""},
	 { "MarkovRandomField__saveGUM", _wrap_MarkovRandomField__saveGUM, METH_VARARGS, "\n"
		"\n"
		"Save the MarkovRandomField in a jgum (JSON) or bgum (binary/msgpack) file.\n"
		"\n"
		"Metadata properties (``software``, ``creation``, ``lastModification``) are updated automatically.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    the file's path\n"
		"binary : bool\n"
		"    if True, write as bgum (msgpack); otherwise write as jgum (JSON) (default: False)\n"
		"indent : int\n"
		"    indentation level for JSON output; -1 for compact, 2 for pretty-printed (default: 2)\n"
		"\n"
		"See Also\n"
		"--------\n"
		":ref:`jgum-bgum-format` : complete format reference\n"
		"\n"
		""},
	 { "MarkovRandomField__saveGUMstring", _wrap_MarkovRandomField__saveGUMstring, METH_VARARGS, "\n"
		"\n"
		"Serialize the MarkovRandomField to a jgum JSON string.\n"
		"\n"
		"Metadata properties (``software``, ``creation``, ``lastModification``) are updated automatically.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"indent : int\n"
		"    indentation level; -1 for compact, 2 for pretty-printed (default: 2)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a JSON string representing the MarkovRandomField in jgum format\n"
		"\n"
		"See Also\n"
		"--------\n"
		":ref:`jgum-bgum-format` : complete format reference\n"
		"\n"
		""},
	 { "MarkovRandomField_loadGUMstring", _wrap_MarkovRandomField_loadGUMstring, METH_VARARGS, "\n"
		"\n"
		"Deserialize a MarkovRandomField from a jgum JSON string.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"content : str\n"
		"    a JSON string in jgum format\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.FatalError\n"
		"    If the string is not valid jgum JSON or the type field does not match ``\"MRF\"``\n"
		"\n"
		"See Also\n"
		"--------\n"
		":ref:`jgum-bgum-format` : complete format reference\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, "\n"
		"\n"
		"Remove the factor that covers a given set of variables.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"vars : set[int] | list[str]\n"
		"    the set of variable ids or names whose factor should be removed\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Replace the triangulation algorithm used to build the junction tree.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"new_triangulation : pyagrum.Triangulation\n"
		"    the new triangulation algorithm\n"
		"\n"
		""},
	 { "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 of 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, "\n"
		"\n"
		"Return the Markov random field associated with this inference engine.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.IMarkovRandomField\n"
		"    the Markov random field\n"
		"\n"
		""},
	 { "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, "\n"
		"\n"
		"Compute the joint mutual information (interaction information) among a set of target variables.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"targets : list[str] or set[int]\n"
		"    the target variables (names or node ids)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"    the joint mutual information\n"
		"\n"
		""},
	 { "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 of int|str\n"
		"  a list of node Ids or node names\n"
		"evs : set\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},
	 { "DoorCriteria_satisfiesBackdoorCriterion", _wrap_DoorCriteria_satisfiesBackdoorCriterion, METH_VARARGS, "\n"
		"\n"
		"Test whether Z satisfies the backdoor criterion for the effect of X on Y.\n"
		"\n"
		"A set Z satisfies the backdoor criterion with respect to (X, Y) if:\n"
		"\n"
		"  1. No node in Z is a descendant of X in the causal DAG.\n"
		"  2. Z blocks every backdoor path between X and Y (paths that begin with an\n"
		"     arc pointing into X).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dag : pyagrum.DAG\n"
		"    The causal DAG.\n"
		"X : int\n"
		"    NodeId of the treatment variable.\n"
		"Y : int\n"
		"    NodeId of the outcome variable.\n"
		"Z : set of int\n"
		"    Candidate adjustment set (NodeIds).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if Z satisfies the backdoor criterion for (X, Y).\n"
		"\n"
		""},
	 { "DoorCriteria_enumerateBackdoorSets", _wrap_DoorCriteria_enumerateBackdoorSets, METH_VARARGS, NULL},
	 { "DoorCriteria_firstBackdoor", _wrap_DoorCriteria_firstBackdoor, METH_VARARGS, "\n"
		"\n"
		"Return the first valid backdoor adjustment set for the causal effect of X on Y.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dag : pyagrum.DAG\n"
		"    The causal DAG.\n"
		"X : int\n"
		"    NodeId of the treatment variable.\n"
		"Y : int\n"
		"    NodeId of the outcome variable.\n"
		"excluded_nodes : set of int, optional\n"
		"    Nodes that cannot appear in any adjustment set. Default is empty.\n"
		"max_cardinality : int, optional\n"
		"    Maximum size of the adjustment set. 0 means no limit. Default is 0.\n"
		"only_minimal : bool, optional\n"
		"    If True, return only a minimal adjustment set. Default is True.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list of int or None\n"
		"    The first valid backdoor adjustment set as a list of NodeIds, or None if none exists.\n"
		"\n"
		""},
	 { "DoorCriteria_satisfiesFrontdoorCriterion", _wrap_DoorCriteria_satisfiesFrontdoorCriterion, METH_VARARGS, "\n"
		"\n"
		"Test whether Z satisfies the frontdoor criterion for the effect of X on Y.\n"
		"\n"
		"A set Z satisfies the frontdoor criterion with respect to (X, Y) if:\n"
		"\n"
		"  1. Z intercepts all directed paths from X to Y.\n"
		"  2. There are no unblocked backdoor paths from X to Z.\n"
		"  3. All backdoor paths from Z to Y are blocked by X.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dag : pyagrum.DAG\n"
		"    The causal DAG.\n"
		"X : int\n"
		"    NodeId of the treatment variable.\n"
		"Y : int\n"
		"    NodeId of the outcome variable.\n"
		"Z : set of int\n"
		"    Candidate mediator set (NodeIds).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if Z satisfies the frontdoor criterion for (X, Y).\n"
		"\n"
		""},
	 { "DoorCriteria_enumerateFrontdoorSets", _wrap_DoorCriteria_enumerateFrontdoorSets, METH_VARARGS, NULL},
	 { "DoorCriteria_firstFrontdoor", _wrap_DoorCriteria_firstFrontdoor, METH_VARARGS, "\n"
		"\n"
		"Return the first valid frontdoor adjustment set for the causal effect of X on Y.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dag : pyagrum.DAG\n"
		"    The causal DAG.\n"
		"X : int\n"
		"    NodeId of the treatment variable.\n"
		"Y : int\n"
		"    NodeId of the outcome variable.\n"
		"excluded_nodes : set of int, optional\n"
		"    Nodes that cannot appear in any adjustment set. Default is empty.\n"
		"max_cardinality : int, optional\n"
		"    Maximum size of the adjustment set. 0 means no limit. Default is 0.\n"
		"only_minimal : bool, optional\n"
		"    If True, return only a minimal adjustment set. Default is True.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list of int or None\n"
		"    The first valid frontdoor adjustment set as a list of NodeIds, or None if none exists.\n"
		"\n"
		""},
	 { "DoorCriteria_existsUnblockedDirectedPath", _wrap_DoorCriteria_existsUnblockedDirectedPath, METH_VARARGS, "\n"
		"\n"
		"Test whether a directed path from X to Y exists that is not blocked by Z.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dag : pyagrum.DAG\n"
		"    The causal DAG.\n"
		"X : int\n"
		"    NodeId of the source variable.\n"
		"Y : int\n"
		"    NodeId of the target variable.\n"
		"Z : set of int\n"
		"    Blocking set (NodeIds). A directed path is blocked if it passes through\n"
		"    a node in Z.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if at least one unblocked directed path from X to Y exists.\n"
		"\n"
		""},
	 { "DoorCriteria_nodesOnDirectedPaths", _wrap_DoorCriteria_nodesOnDirectedPaths, METH_VARARGS, "\n"
		"\n"
		"Return the set of nodes lying on any directed path from X to Y.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dag : pyagrum.DAG\n"
		"    The causal DAG.\n"
		"X : int\n"
		"    NodeId of the source variable.\n"
		"Y : int\n"
		"    NodeId of the target variable.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set of int\n"
		"    NodeIds of all nodes (including X and Y) that lie on at least one\n"
		"    directed path from X to Y. Empty if no directed path exists.\n"
		"\n"
		""},
	 { "DoorCriteria_backdoorReach", _wrap_DoorCriteria_backdoorReach, METH_VARARGS, "\n"
		"\n"
		"Return all nodes reachable from X via a backdoor path.\n"
		"\n"
		"A backdoor path starts with an arc pointing *into* X (i.e. it begins by\n"
		"going to a parent of X) and then follows any sequence of edges.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dag : pyagrum.DAG\n"
		"    The causal DAG.\n"
		"X : int\n"
		"    NodeId of the source variable.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set of int\n"
		"    NodeIds of all nodes reachable from X via a backdoor path.\n"
		"\n"
		""},
	 { "DoorCriteria_hasBackdoorPath", _wrap_DoorCriteria_hasBackdoorPath, METH_VARARGS, "\n"
		"\n"
		"Test whether an open backdoor path from X to Y exists given evidence on Z.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dag : pyagrum.DAG\n"
		"    The causal DAG.\n"
		"X : int\n"
		"    NodeId of the treatment variable.\n"
		"Y : int\n"
		"    NodeId of the outcome variable.\n"
		"Z : set of int\n"
		"    Conditioning set (NodeIds).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if an open backdoor path from X to Y exists after conditioning on Z.\n"
		"\n"
		""},
	 { "new_DoorCriteria", _wrap_new_DoorCriteria, METH_NOARGS, NULL},
	 { "delete_DoorCriteria", _wrap_delete_DoorCriteria, METH_O, NULL},
	 { "DoorCriteria_swigregister", DoorCriteria_swigregister, METH_O, NULL},
	 { "DoorCriteria_swiginit", DoorCriteria_swiginit, METH_VARARGS, NULL},
	 { "_causalImpact", _wrap__causalImpact, METH_VARARGS, NULL},
	 { "delete_CausalModel", _wrap_delete_CausalModel, METH_O, NULL},
	 { "CausalModel_addLatentVariable", _wrap_CausalModel_addLatentVariable, METH_VARARGS, "\n"
		"\n"
		"Add a latent (hidden) variable to the causal model.\n"
		"\n"
		"The latent variable is added as a common cause of the specified children.\n"
		"By default, any existing arc between two affected children is removed, as\n"
		"it is assumed to be explained by the new latent confounder.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    Name of the new latent variable.\n"
		"children : list of str\n"
		"    Names of the observed variables that are children of this latent variable.\n"
		"assumeNonSpurious : bool, optional\n"
		"    If True, preserve existing arcs between the specified children.\n"
		"    Default is False.\n"
		"\n"
		""},
	 { "CausalModel_existsArc", _wrap_CausalModel_existsArc, METH_VARARGS, "\n"
		"\n"
		"Check whether an arc exists in the causal DAG.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x : int or str\n"
		"    Tail of the arc (NodeId or variable name).\n"
		"y : int or str\n"
		"    Head of the arc (NodeId or variable name).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the arc x→y exists in the causal DAG.\n"
		"\n"
		""},
	 { "CausalModel_assumeSpurious", _wrap_CausalModel_assumeSpurious, METH_VARARGS, "\n"
		"\n"
		"Mark an arc in the causal DAG as spurious.\n"
		"\n"
		"A spurious arc x→y means the observed correlation between x and y is believed\n"
		"to be explained by a latent common cause rather than a direct causal effect.\n"
		"This changes the structural interpretation but does not remove the arc.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x : int or str\n"
		"    Tail of the arc (NodeId or variable name).\n"
		"y : int or str\n"
		"    Head of the arc (NodeId or variable name).\n"
		"\n"
		""},
	 { "CausalModel_assumeNonSpurious", _wrap_CausalModel_assumeNonSpurious, METH_VARARGS, "\n"
		"\n"
		"Mark an arc in the causal DAG as non-spurious (a genuine causal effect).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x : int or str\n"
		"    Tail of the arc (NodeId or variable name).\n"
		"y : int or str\n"
		"    Head of the arc (NodeId or variable name).\n"
		"\n"
		""},
	 { "CausalModel_isAssumedSpurious", _wrap_CausalModel_isAssumedSpurious, METH_VARARGS, "\n"
		"\n"
		"Check whether the arc x→y is assumed spurious.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x : int or str\n"
		"    Tail of the arc (NodeId or variable name).\n"
		"y : int or str\n"
		"    Head of the arc (NodeId or variable name).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the arc x→y is marked as spurious.\n"
		"\n"
		""},
	 { "CausalModel_backDoor", _wrap_CausalModel_backDoor, METH_VARARGS, "\n"
		"\n"
		"Find a backdoor adjustment set between cause and effect.\n"
		"\n"
		"Returns the first valid backdoor adjustment set found. A backdoor set Z\n"
		"blocks all spurious (non-causal) paths between cause and effect while\n"
		"leaving all directed causal paths open, enabling estimation of the causal\n"
		"effect P(effect | do(cause)) via standard conditioning on Z.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"cause : int or str\n"
		"    The treatment variable (NodeId or variable name).\n"
		"effect : int or str\n"
		"    The outcome variable (NodeId or variable name).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set of int or None\n"
		"    A valid backdoor adjustment set as NodeIds, or ``None`` if no backdoor set\n"
		"    exists. Note: an empty set is a *valid* backdoor (returned when X has no\n"
		"    back-door paths); ``None`` means the causal effect cannot be identified via\n"
		"    the backdoor criterion.\n"
		"\n"
		"See Also\n"
		"--------\n"
		"pyagrum.DoorCriteria.enumerateBackdoorSets : enumerate all valid sets.\n"
		"\n"
		""},
	 { "CausalModel_frontDoor", _wrap_CausalModel_frontDoor, METH_VARARGS, "\n"
		"\n"
		"Find a frontdoor adjustment set between cause and effect.\n"
		"\n"
		"Returns the first valid frontdoor adjustment set found. A frontdoor set Z\n"
		"intercepts all directed paths from cause to effect and enables estimation of\n"
		"P(effect | do(cause)) even in the presence of unobserved confounders.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"cause : int or str\n"
		"    The treatment variable (NodeId or variable name).\n"
		"effect : int or str\n"
		"    The outcome variable (NodeId or variable name).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set of int or None\n"
		"    A valid frontdoor adjustment set as NodeIds, or ``None`` if no frontdoor\n"
		"    set exists. Note: an empty set is a *valid* frontdoor in degenerate cases;\n"
		"    ``None`` means the causal effect cannot be identified via the frontdoor\n"
		"    criterion.\n"
		"\n"
		"See Also\n"
		"--------\n"
		"pyagrum.DoorCriteria.enumerateFrontdoorSets : enumerate all valid sets.\n"
		"\n"
		""},
	 { "CausalModel_inducedCausalSubModel", _wrap_CausalModel_inducedCausalSubModel, METH_VARARGS, "\n"
		"\n"
		"Return the causal sub-model induced by a subset of observed nodes.\n"
		"\n"
		"The sub-model is restricted to the specified nodes, preserving the relevant\n"
		"portion of the causal DAG and latent structure.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"cm : pyagrum.CausalModel\n"
		"    The original causal model.\n"
		"subset : set of int\n"
		"    NodeIds of the observed variables to keep.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CausalModel\n"
		"    The induced causal sub-model.\n"
		"\n"
		""},
	 { "CausalModel_toDot", _wrap_CausalModel_toDot, METH_VARARGS, "\n"
		"\n"
		"Return a Graphviz dot string representing the causal model.\n"
		"\n"
		"Observed nodes are shown with default styling. Latent nodes are displayed\n"
		"with a distinct background colour. Their names are hidden by default.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"SHOW_LATENT_NAMES : bool, optional\n"
		"    If True, display the names of latent nodes in the graph. Default is False.\n"
		"NODE_BG : str, optional\n"
		"    Background colour for latent nodes (hex or CSS colour name).\n"
		"    Default is '#404040'.\n"
		"NODE_FG : str, optional\n"
		"    Text colour for latent nodes. Default is 'white'.\n"
		"EDGE_COL : str, optional\n"
		"    Edge colour. Default is '#4A4A4A'.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    A dot-format string representation of the causal model.\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> import pyagrum as gum\n"
		">>> bn = gum.BayesNet.fastPrototype('X->Y->Z')\n"
		">>> cm = gum.CausalModel(bn)\n"
		">>> print(cm.toDot())\n"
		"\n"
		""},
	 { "CausalModel_observationalBN", _wrap_CausalModel_observationalBN, METH_O, "\n"
		"\n"
		"Return the observational Bayesian network underlying the causal model.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Do not use this BN for causal inference. It represents the observational\n"
		"distribution only. Use :func:`pyagrum.causalImpact` for\n"
		"interventional queries.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.BayesNet\n"
		"    The observational BN (observed variables only).\n"
		"\n"
		""},
	 { "CausalModel_causalDAG", _wrap_CausalModel_causalDAG, METH_O, "\n"
		"\n"
		"Return the full causal DAG, including latent variables.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DAG\n"
		"    The causal DAG (observed + latent nodes).\n"
		"\n"
		""},
	 { "CausalModel_names", _wrap_CausalModel_names, METH_O, "\n"
		"\n"
		"Return the names of all variables in the causal model (observed and latent).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set of str\n"
		"    The set of all variable names.\n"
		"\n"
		""},
	 { "CausalModel_idFromName", _wrap_CausalModel_idFromName, METH_VARARGS, "\n"
		"\n"
		"Return the NodeId of a variable by name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"    The variable name.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    The NodeId of the variable.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    If no variable with that name exists in the causal model.\n"
		"\n"
		""},
	 { "CausalModel_nameFromId", _wrap_CausalModel_nameFromId, METH_VARARGS, "\n"
		"\n"
		"Return the name of a variable by NodeId.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    The NodeId of the variable.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    The variable name.\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    If no variable with that NodeId exists in the causal model.\n"
		"\n"
		""},
	 { "CausalModel_latentVariablesIds", _wrap_CausalModel_latentVariablesIds, METH_O, "\n"
		"\n"
		"Return the NodeIds of all latent (hidden) variables in the causal model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set of int\n"
		"    NodeIds of latent variables.\n"
		"\n"
		""},
	 { "CausalModel_latentVariablesNames", _wrap_CausalModel_latentVariablesNames, METH_O, "\n"
		"\n"
		"Return the names of all latent (hidden) variables in the causal model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set of str\n"
		"    Names of latent variables.\n"
		"\n"
		""},
	 { "CausalModel_parents", _wrap_CausalModel_parents, METH_VARARGS, "\n"
		"\n"
		"Return the parents of a variable in the causal DAG.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x : int or str\n"
		"    The variable (NodeId or name).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set of int\n"
		"    NodeIds of the variable's parents in the causal DAG.\n"
		"\n"
		""},
	 { "CausalModel_children", _wrap_CausalModel_children, METH_VARARGS, "\n"
		"\n"
		"Return the children of a variable in the causal DAG.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x : int or str\n"
		"    The variable (NodeId or name).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set of int\n"
		"    NodeIds of the variable's children in the causal DAG.\n"
		"\n"
		""},
	 { "CausalModel_connectedComponents", _wrap_CausalModel_connectedComponents, METH_O, "\n"
		"\n"
		"Return the connected components of the causal DAG (treating arcs as undirected).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict of int → set of int\n"
		"    A mapping from component index to the set of NodeIds in that component.\n"
		"\n"
		""},
	 { "CausalModel_variable", _wrap_CausalModel_variable, METH_VARARGS, "\n"
		"\n"
		"Return the variable with the given id or name (observed variables only).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id_or_name : int | str\n"
		"    the node id or name of the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.DiscreteVariable\n"
		"    the discrete variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.NotFound\n"
		"    if the id or name does not correspond to an observed variable in the model\n"
		"\n"
		""},
	 { "new_CausalModel", _wrap_new_CausalModel, METH_VARARGS, NULL},
	 { "CausalModel_swigregister", CausalModel_swigregister, METH_O, NULL},
	 { "CausalModel_swiginit", CausalModel_swiginit, METH_VARARGS, NULL},
	 { "CausalImpact_eval", _wrap_CausalImpact_eval, METH_O, "\n"
		"\n"
		"Evaluate the identified causal formula and return the result as a tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"    The distribution P(on | do(doing), knowing).\n"
		"\n"
		"Raises\n"
		"------\n"
		"pyagrum.OperationNotAllowed\n"
		"    If the causal effect is not identified (:meth:`isIdentified` is False).\n"
		"\n"
		""},
	 { "CausalImpact_toString", _wrap_CausalImpact_toString, METH_O, "\n"
		"\n"
		"Return a string representation of the identified causal formula.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    Human-readable form of the formula (e.g. a sum-product expression over\n"
		"    conditional probabilities).\n"
		"\n"
		""},
	 { "CausalImpact_toLatex", _wrap_CausalImpact_toLatex, METH_VARARGS, "\n"
		"\n"
		"Return a LaTeX representation of the identified causal formula.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"doOperatorPrefix : str, optional\n"
		"    Prefix for the do-operator notation. Defaults to\n"
		"    ``gum.config[\"causal\", \"latex_do_prefix\"]``.\n"
		"doOperatorSuffix : str, optional\n"
		"    Suffix for the do-operator notation. Defaults to\n"
		"    ``gum.config[\"causal\", \"latex_do_suffix\"]``.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    LaTeX string of the identified formula.\n"
		"\n"
		""},
	 { "CausalImpact_latexQuery", _wrap_CausalImpact_latexQuery, METH_VARARGS, "\n"
		"\n"
		"Return a LaTeX string for the original causal query before identification.\n"
		"\n"
		"The query has the form P(on | do(doing), knowing).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"doOperatorPrefix : str, optional\n"
		"    Prefix for the do-operator notation. Default is 'do('.\n"
		"doOperatorSuffix : str, optional\n"
		"    Suffix for the do-operator notation. Default is ')'.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    LaTeX string of the causal query.\n"
		"\n"
		""},
	 { "CausalImpact_isIdentified", _wrap_CausalImpact_isIdentified, METH_O, "\n"
		"\n"
		"Return True if the causal effect was successfully identified.\n"
		"\n"
		"If False, the effect cannot be computed from the available data given\n"
		"the causal structure, and :meth:`eval` will raise an exception.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the query is identifiable.\n"
		"\n"
		""},
	 { "CausalImpact_cm", _wrap_CausalImpact_cm, METH_O, "\n"
		"\n"
		"Return the causal model associated with this query.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CausalModel\n"
		"    The causal model.\n"
		"\n"
		""},
	 { "CausalImpact_on", _wrap_CausalImpact_on, METH_O, "\n"
		"\n"
		"Return the NodeIds of the target variables.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set of int\n"
		"    NodeIds of the variables in the on-set.\n"
		"\n"
		""},
	 { "CausalImpact_doing", _wrap_CausalImpact_doing, METH_O, "\n"
		"\n"
		"Return the NodeIds of the intervened variables.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set of int\n"
		"    NodeIds of the variables in the doing-set (do-operator).\n"
		"\n"
		""},
	 { "CausalImpact_knowing", _wrap_CausalImpact_knowing, METH_O, "\n"
		"\n"
		"Return the NodeIds of the observed variables.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set of int\n"
		"    NodeIds of the variables in the knowing-set.\n"
		"\n"
		""},
	 { "CausalImpact_explanation", _wrap_CausalImpact_explanation, METH_O, "\n"
		"\n"
		"Return a human-readable explanation of the identification result.\n"
		"\n"
		"Describes the method used (e.g. 'd-separation', 'backdoor adjustment',\n"
		"'frontdoor adjustment', 'do-calculus (ID)') or explains why identification\n"
		"failed.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    Explanation of the identification outcome.\n"
		"\n"
		""},
	 { "CausalImpact_onNames", _wrap_CausalImpact_onNames, METH_O, "\n"
		"\n"
		"Return the names of the target variables.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple of str\n"
		"    Variable names in the on-set.\n"
		"\n"
		""},
	 { "CausalImpact_doingNames", _wrap_CausalImpact_doingNames, METH_O, "\n"
		"\n"
		"Return the names of the intervened variables.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple of str\n"
		"    Variable names in the doing-set.\n"
		"\n"
		""},
	 { "CausalImpact_knowingNames", _wrap_CausalImpact_knowingNames, METH_O, "\n"
		"\n"
		"Return the names of the observed variables.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple of str\n"
		"    Variable names in the knowing-set.\n"
		"\n"
		""},
	 { "new_CausalImpact", _wrap_new_CausalImpact, METH_VARARGS, NULL},
	 { "CausalImpact_toDict", _wrap_CausalImpact_toDict, METH_O, "\n"
		"\n"
		"Return the identified causal formula as a JSON-serialisable dictionary.\n"
		"\n"
		"The dictionary mirrors the AST node hierarchy. Each node is a dict with\n"
		"an ``\"op\"`` key identifying its type, plus type-specific keys:\n"
		"\n"
		"- Binary operators (``+``, ``-``, ``*``, ``/``):\n"
		"  ``{\"op\": \"+\", \"op1\": {...}, \"op2\": {...}}``\n"
		"- Conditional probability ``P(vars | knowing)``:\n"
		"  ``{\"op\": \"P\", \"vars\": [...], \"knowing\": [...]}``\n"
		"- Joint probability ``P(vars)``:\n"
		"  ``{\"op\": \"P\", \"vars\": [...]}``\n"
		"- Summation / marginalisation :math:`\\sum_{\\text{var}}`:\n"
		"  ``{\"op\": \"sum\", \"var\": \"...\", \"term\": {...}}``\n"
		"\n"
		"Returns ``None`` if the effect is not identified\n"
		"(i.e. :meth:`isIdentified` is False).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict or None\n"
		"    The AST as a nested dict, or None if not identifiable.\n"
		"\n"
		"Examples\n"
		"--------\n"
		">>> import pyagrum as gum\n"
		">>> bn = gum.BayesNet.fastPrototype('X->Y->Z')\n"
		">>> cm = gum.CausalModel(bn)\n"
		">>> ci = gum.CausalImpact(cm, on='Z', doing='X')\n"
		">>> import json\n"
		">>> print(json.dumps(ci.toDict(), indent=2))\n"
		"\n"
		""},
	 { "delete_CausalImpact", _wrap_delete_CausalImpact, METH_O, NULL},
	 { "CausalImpact_swigregister", CausalImpact_swigregister, METH_O, NULL},
	 { "CausalImpact_swiginit", CausalImpact_swiginit, METH_VARARGS, NULL},
	 { "new_Counterfactual", _wrap_new_Counterfactual, METH_VARARGS, NULL},
	 { "Counterfactual_counterFactualModel", _wrap_Counterfactual_counterFactualModel, METH_VARARGS, "\n"
		"\n"
		"Build the twin causal model from the original model and a factual profile.\n"
		"\n"
		"This static method implements steps 1-2 of the three-step counterfactual\n"
		"algorithm: it computes the posterior of parentless (idiosyncratic) nodes\n"
		"in the observational BN given the profile evidence, then replaces their\n"
		"prior distributions in a copy of the model with those posteriors.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"cm : pyagrum.CausalModel\n"
		"    The original causal model.\n"
		"profile : dict of str → str\n"
		"    The factual observation as ``{variable_name: value_name}``.\n"
		"whatif : set of str\n"
		"    Intervened variables in the counterfactual scenario. These are excluded\n"
		"    from the set of idiosyncratic nodes that get updated.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CausalModel\n"
		"    The twin causal model ready for the prediction step.\n"
		"\n"
		"See Also\n"
		"--------\n"
		"pyagrum.counterfactualModel : high-level function wrapper.\n"
		"\n"
		""},
	 { "Counterfactual_run", _wrap_Counterfactual_run, METH_O, "\n"
		"\n"
		"Execute the counterfactual computation (steps 2 and 3).\n"
		"\n"
		"This method is called automatically by the constructor. Call it explicitly\n"
		"only if you need to re-run after modifying the object's state.\n"
		"\n"
		""},
	 { "Counterfactual_originalModel", _wrap_Counterfactual_originalModel, METH_O, "\n"
		"\n"
		"Return the original causal model.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CausalModel\n"
		"    The original causal model passed to the constructor.\n"
		"\n"
		""},
	 { "Counterfactual_twinModel", _wrap_Counterfactual_twinModel, METH_O, "\n"
		"\n"
		"Return the twin causal model built during the abduction step.\n"
		"\n"
		"The twin model has the same structure as the original but with updated\n"
		"priors for parentless nodes (based on the observed profile).\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.CausalModel\n"
		"    The twin model.\n"
		"\n"
		""},
	 { "Counterfactual_impact", _wrap_Counterfactual_impact, METH_O, NULL},
	 { "Counterfactual_value", _wrap_Counterfactual_value, METH_O, "\n"
		"\n"
		"Return the counterfactual distribution as a tensor.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyagrum.Tensor\n"
		"    The distribution P(on | do(whatif)) evaluated on the twin model,\n"
		"    optionally sliced by *values* if provided at construction.\n"
		"\n"
		""},
	 { "Counterfactual_on", _wrap_Counterfactual_on, METH_O, "\n"
		"\n"
		"Return the names of the target variables.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set of str\n"
		"    Variable names in the on-set.\n"
		"\n"
		""},
	 { "Counterfactual_whatif", _wrap_Counterfactual_whatif, METH_O, "\n"
		"\n"
		"Return the names of the intervened variables.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set of str\n"
		"    Variable names in the whatif-set.\n"
		"\n"
		""},
	 { "Counterfactual_profile", _wrap_Counterfactual_profile, METH_O, "\n"
		"\n"
		"Return the factual evidence used for abduction.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict of str → str\n"
		"    The observed profile as ``{variable_name: value_name}``.\n"
		"\n"
		""},
	 { "Counterfactual_values", _wrap_Counterfactual_values, METH_O, "\n"
		"\n"
		"Return the counterfactual assignments for the whatif variables.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict of str → str\n"
		"    The counterfactual values as ``{variable_name: value_name}``.\n"
		"    Empty dict if no specific values were requested.\n"
		"\n"
		""},
	 { "Counterfactual_toString", _wrap_Counterfactual_toString, METH_O, "\n"
		"\n"
		"Return a string description of the counterfactual query and its result.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    Human-readable summary of the counterfactual computation.\n"
		"\n"
		""},
	 { "delete_Counterfactual", _wrap_delete_Counterfactual, METH_O, NULL},
	 { "Counterfactual_swigregister", Counterfactual_swigregister, METH_O, NULL},
	 { "Counterfactual_swiginit", Counterfactual_swiginit, METH_VARARGS, NULL},
	 { "_counterfactual", _wrap__counterfactual, METH_VARARGS, NULL},
	 { "_counterfactualModel", _wrap__counterfactualModel, 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__MCBNDistanceT_double_tTo_p_gum__ApproximationScheme(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ApproximationScheme *)  ((gum::MCBNDistance< 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__MCBNDistanceT_double_tTo_p_gum__BNdistanceT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::BNdistance< double > *)  ((gum::MCBNDistance< 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__BayesNetT_double_tTo_p_gum__DiscreteGraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteGraphicalModel *) (gum::DAGmodel *)(gum::IBayesNet< double > *) ((gum::BayesNet< double > *) x));
}
static void *_p_gum__BayesNetFragmentT_double_tTo_p_gum__DiscreteGraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteGraphicalModel *) (gum::DAGmodel *)(gum::IBayesNet< double > *) ((gum::BayesNetFragment< double > *) x));
}
static void *_p_gum__DAGmodelTo_p_gum__DiscreteGraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteGraphicalModel *)  ((gum::DAGmodel *) x));
}
static void *_p_gum__IBayesNetT_double_tTo_p_gum__DiscreteGraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteGraphicalModel *) (gum::DAGmodel *) ((gum::IBayesNet< double > *) x));
}
static void *_p_gum__IMarkovRandomFieldT_double_tTo_p_gum__DiscreteGraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteGraphicalModel *) (gum::UGmodel *) ((gum::IMarkovRandomField< double > *) x));
}
static void *_p_gum__InfluenceDiagramT_double_tTo_p_gum__DiscreteGraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteGraphicalModel *) (gum::DAGmodel *) ((gum::InfluenceDiagram< double > *) x));
}
static void *_p_gum__MarkovRandomFieldT_double_tTo_p_gum__DiscreteGraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteGraphicalModel *) (gum::UGmodel *)(gum::IMarkovRandomField< double > *) ((gum::MarkovRandomField< double > *) x));
}
static void *_p_gum__UGmodelTo_p_gum__DiscreteGraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteGraphicalModel *)  ((gum::UGmodel *) 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__PAGTo_p_gum__EdgeGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::EdgeGraphPart *) (gum::UndiGraph *) ((gum::PAG *) 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__HedgeExceptionTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::HedgeException *) 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::DiscreteGraphicalModel *)(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::DiscreteGraphicalModel *)(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::DiscreteGraphicalModel *) ((gum::DAGmodel *) x));
}
static void *_p_gum__DiscreteGraphicalModelTo_p_gum__GraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphicalModel *)  ((gum::DiscreteGraphicalModel *) x));
}
static void *_p_gum__IBayesNetT_double_tTo_p_gum__GraphicalModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphicalModel *) (gum::DiscreteGraphicalModel *)(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::DiscreteGraphicalModel *)(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::DiscreteGraphicalModel *)(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::DiscreteGraphicalModel *)(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::DiscreteGraphicalModel *) ((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__MCBNDistanceT_double_tTo_p_gum__IApproximationSchemeConfiguration(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::IApproximationSchemeConfiguration *) (gum::ApproximationScheme *) ((gum::MCBNDistance< 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__PAGTo_p_gum__NodeGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::NodeGraphPart *) (gum::UndiGraph *) ((gum::PAG *) 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__PAGTo_p_gum__UndiGraph(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::UndiGraph *)  ((gum::PAG *) 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__HedgeExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (gum::Exception *) ((gum::HedgeException *) 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_HashTableT_std__size_t_gum__SetT_std__size_t_t_t = {"_p_HashTableT_std__size_t_gum__SetT_std__size_t_t_t", "HashTable< gum::NodeId,gum::NodeSet > *|HashTable< std::size_t,gum::Set< std::size_t > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HashTableT_std__size_t_std__size_t_t = {"_p_HashTableT_std__size_t_std__size_t_t", "HashTable< gum::NodeId,gum::Idx > *|HashTable< std::size_t,std::size_t > *", 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_NodeSetVec = {"_p_NodeSetVec", "NodeSetVec *", 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_PyObject = {"_p_PyObject", "PyAgrumArgMinMax *|PyAgrumBool *|PyAgrumDict *|PyAgrumDictSF *|PyAgrumDictState *|PyAgrumFloat *|PyAgrumInstDict *|PyAgrumList *|PyAgrumListOfArc *|PyAgrumListOfInt *|PyAgrumListOfSetOfInt *|PyAgrumListOfStr *|PyAgrumNdArray *|PyAgrumNone *|PyAgrumSetOfArc *|PyAgrumSetOfEdge *|PyAgrumSetOfInt *|PyAgrumSetOfStr *|PyAgrumStr *|PyAgrumTupleFF *|PyAgrumTupleOfInt *|PyObject *", 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_ValName = {"_p_ValName", "ValName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VarName = {"_p_VarName", "VarName *", 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__CausalImpactT_double_t = {"_p_gum__CausalImpactT_double_t", "gum::CausalImpact< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__CausalModelT_double_t = {"_p_gum__CausalModelT_double_t", "gum::CausalModel< double > *", 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__CounterfactualT_double_t = {"_p_gum__CounterfactualT_double_t", "gum::Counterfactual< double > *", 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__DiscreteGraphicalModel = {"_p_gum__DiscreteGraphicalModel", "gum::DiscreteGraphicalModel *", 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__DoorCriteria = {"_p_gum__DoorCriteria", "gum::DoorCriteria *", 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__HedgeException = {"_p_gum__HedgeException", "gum::HedgeException *", 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__MCBNDistanceT_double_t = {"_p_gum__MCBNDistanceT_double_t", "gum::MCBNDistance< double > *", 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_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t = {"_p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t", "gum::NodeProperty< std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__NotFound = {"_p_gum__NotFound", "gum::NotFound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__NotImplementedYet = {"_p_gum__NotImplementedYet", "gum::NotImplementedYet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__NullElement = {"_p_gum__NullElement", "gum::NullElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__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__PAG = {"_p_gum__PAG", "gum::PAG *", 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__StructuralMetrics = {"_p_gum__StructuralMetrics", "gum::StructuralMetrics *", 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_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__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__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_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_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_std__allocatorT_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t_t = {"_p_std__vectorT_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_std__allocatorT_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t_t", "gum::LatentDescriptorVector *|std::vector< std::pair< std::string,std::vector< std::size_t,std::allocator< std::size_t > > >,std::allocator< std::pair< std::string,std::vector< std::size_t,std::allocator< 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__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t = {"_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t", "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t = {"_p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t", "std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t = {"_p_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t", "std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_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_HashTableT_std__size_t_gum__SetT_std__size_t_t_t,
  &_swigt__p_HashTableT_std__size_t_std__size_t_t,
  &_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_NodeSetVec,
  &_swigt__p_PRMexplorer,
  &_swigt__p_PyObject,
  &_swigt__p_PythonApproximationListener,
  &_swigt__p_PythonBNListener,
  &_swigt__p_PythonDatabaseGeneratorListener,
  &_swigt__p_PythonLoadListener,
  &_swigt__p_ValName,
  &_swigt__p_VarName,
  &_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__CausalImpactT_double_t,
  &_swigt__p_gum__CausalModelT_double_t,
  &_swigt__p_gum__CliqueGraph,
  &_swigt__p_gum__CounterfactualT_double_t,
  &_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__DiscreteGraphicalModel,
  &_swigt__p_gum__DiscreteVariable,
  &_swigt__p_gum__DiscretizedVariableT_double_t,
  &_swigt__p_gum__DoorCriteria,
  &_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__HedgeException,
  &_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__MCBNDistanceT_double_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_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t,
  &_swigt__p_gum__NotFound,
  &_swigt__p_gum__NotImplementedYet,
  &_swigt__p_gum__NullElement,
  &_swigt__p_gum__NumericalDiscreteVariable,
  &_swigt__p_gum__OperationNotAllowed,
  &_swigt__p_gum__OutOfBounds,
  &_swigt__p_gum__PAG,
  &_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__StructuralMetrics,
  &_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_second_type,
  &_swigt__p_size_type,
  &_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__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_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_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_std__allocatorT_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t_t,
  &_swigt__p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t,
  &_swigt__p_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_HashTableT_std__size_t_gum__SetT_std__size_t_t_t[] = {  {&_swigt__p_HashTableT_std__size_t_gum__SetT_std__size_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HashTableT_std__size_t_std__size_t_t[] = {  {&_swigt__p_HashTableT_std__size_t_std__size_t_t, 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_NodeSetVec[] = {  {&_swigt__p_NodeSetVec, 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_PyObject[] = {  {&_swigt__p_PyObject, 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_ValName[] = {  {&_swigt__p_ValName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VarName[] = {  {&_swigt__p_VarName, 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},  {&_swigt__p_gum__MCBNDistanceT_double_t, _p_gum__MCBNDistanceT_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},  {&_swigt__p_gum__MCBNDistanceT_double_t, _p_gum__MCBNDistanceT_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__CausalImpactT_double_t[] = {  {&_swigt__p_gum__CausalImpactT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__CausalModelT_double_t[] = {  {&_swigt__p_gum__CausalModelT_double_t, 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__CounterfactualT_double_t[] = {  {&_swigt__p_gum__CounterfactualT_double_t, 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__DiscreteGraphicalModel[] = {  {&_swigt__p_gum__DiscreteGraphicalModel, 0, 0, 0},  {&_swigt__p_gum__BayesNetFragmentT_double_t, _p_gum__BayesNetFragmentT_double_tTo_p_gum__DiscreteGraphicalModel, 0, 0},  {&_swigt__p_gum__BayesNetT_double_t, _p_gum__BayesNetT_double_tTo_p_gum__DiscreteGraphicalModel, 0, 0},  {&_swigt__p_gum__DAGmodel, _p_gum__DAGmodelTo_p_gum__DiscreteGraphicalModel, 0, 0},  {&_swigt__p_gum__IBayesNetT_double_t, _p_gum__IBayesNetT_double_tTo_p_gum__DiscreteGraphicalModel, 0, 0},  {&_swigt__p_gum__IMarkovRandomFieldT_double_t, _p_gum__IMarkovRandomFieldT_double_tTo_p_gum__DiscreteGraphicalModel, 0, 0},  {&_swigt__p_gum__InfluenceDiagramT_double_t, _p_gum__InfluenceDiagramT_double_tTo_p_gum__DiscreteGraphicalModel, 0, 0},  {&_swigt__p_gum__MarkovRandomFieldT_double_t, _p_gum__MarkovRandomFieldT_double_tTo_p_gum__DiscreteGraphicalModel, 0, 0},  {&_swigt__p_gum__UGmodel, _p_gum__UGmodelTo_p_gum__DiscreteGraphicalModel, 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__DoorCriteria[] = {  {&_swigt__p_gum__DoorCriteria, 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__PAG, _p_gum__PAGTo_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__HedgeException, _p_gum__HedgeExceptionTo_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__DiscreteGraphicalModel, _p_gum__DiscreteGraphicalModelTo_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__HedgeException[] = {  {&_swigt__p_gum__HedgeException, 0, 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__MCBNDistanceT_double_t, _p_gum__MCBNDistanceT_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__MCBNDistanceT_double_t[] = {  {&_swigt__p_gum__MCBNDistanceT_double_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__PAG, _p_gum__PAGTo_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_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t[] = {  {&_swigt__p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__NotFound[] = {  {&_swigt__p_gum__NotFound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__NotImplementedYet[] = {  {&_swigt__p_gum__NotImplementedYet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__NullElement[] = {  {&_swigt__p_gum__NullElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__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__PAG[] = {  {&_swigt__p_gum__PAG, 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__StructuralMetrics[] = {  {&_swigt__p_gum__StructuralMetrics, 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__PAG, _p_gum__PAGTo_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_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__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__HedgeException, _p_gum__HedgeExceptionTo_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__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_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_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_std__allocatorT_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_std__allocatorT_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_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__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_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_HashTableT_std__size_t_gum__SetT_std__size_t_t_t,
  _swigc__p_HashTableT_std__size_t_std__size_t_t,
  _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_NodeSetVec,
  _swigc__p_PRMexplorer,
  _swigc__p_PyObject,
  _swigc__p_PythonApproximationListener,
  _swigc__p_PythonBNListener,
  _swigc__p_PythonDatabaseGeneratorListener,
  _swigc__p_PythonLoadListener,
  _swigc__p_ValName,
  _swigc__p_VarName,
  _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__CausalImpactT_double_t,
  _swigc__p_gum__CausalModelT_double_t,
  _swigc__p_gum__CliqueGraph,
  _swigc__p_gum__CounterfactualT_double_t,
  _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__DiscreteGraphicalModel,
  _swigc__p_gum__DiscreteVariable,
  _swigc__p_gum__DiscretizedVariableT_double_t,
  _swigc__p_gum__DoorCriteria,
  _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__HedgeException,
  _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__MCBNDistanceT_double_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_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t,
  _swigc__p_gum__NotFound,
  _swigc__p_gum__NotImplementedYet,
  _swigc__p_gum__NullElement,
  _swigc__p_gum__NumericalDiscreteVariable,
  _swigc__p_gum__OperationNotAllowed,
  _swigc__p_gum__OutOfBounds,
  _swigc__p_gum__PAG,
  _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__StructuralMetrics,
  _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_second_type,
  _swigc__p_size_type,
  _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__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_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_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_std__allocatorT_std__pairT_std__string_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t_t,
  _swigc__p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t,
  _swigc__p_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 made 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 dependencies. 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.
 *
 * We loop through the cast[] array associated with the type and mark casts
 * which have not been defined in previously loaded modules by assigning
 * cast pointer value to cast->next. We also hash cast->type->name string
 * and store the value in the cast->value field. If we encounter swig_cast_info
 * structure that represents a cast to self we move it to the beginning
 * of the cast array. One 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 list (because the cast->type) pointer will
 *     be correct.
 *
 * Once the cast array has been set up AND it does have new casts that need
 * to be added we sort non-self cast entries to move filtered out entries
 * to the end of the array and to arrange the rest in the increasing order
 * of their type pointer values. We store the index of the last added entry
 * in the cast->value field of the entry[0] (overwriting the name hash). Then
 * we sort <next|value> fields of the remaining entries to arrange hash values
 * in the increasing order. This way cast->next->type->name field matches
 * the cast->value hash.
 *
 * Example:
 * Array of casts for type stored at 0x5000, cast to type stored at 0x3000
 * has already been loaded
 *
 *      After sweep-and-hash:   After sort-by-type:    After sort-by-hash:
 *        ________________       ________________       ________________
 *       |                |     |                |     |                |
 * Entry |  type = 0x5000 |     |  type = 0x5000 |     |  type = 0x5000 |
 *   0   |                |     |                |     |                |
 *       |  next = Entry0 |     |  next = Entry0 |     |  next = Entry0 |
 *       | value = 1212   |     | value = 3      |     | value = 3      |
 *       |                |     |                |     |                |
 *       |================|     |================|     |================|
 *       |                |     |                |     |                |
 * Entry |  type = 0x2000 |     |  type = 0x1000 |     |  type = 0x1000 |
 *   1   |                |     |                |     |                |
 *       |  next = Entry1 |     |  next = Entry1 |     |  next = Entry3 |
 *       | value = 3434   |     | value = 4545   |     | value = 2323   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x3000 |     |  type = 0x2000 |     |  type = 0x2000 |
 *   2   |                |     |                |     |                |
 *       |  next = 0      |     |  next = Entry2 |     |  next = Entry2 |
 *       | value = 0      |     | value = 3434   |     | value = 3434   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x1000 |     |  type = 0x4000 |     |  type = 0x4000 |
 *   3   |                |     |                |     |                |
 *       |  next = Entry3 |     |  next = Entry3 |     |  next = Entry1 |
 *       | value = 4545   |     | value = 2323   |     | value = 4545   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x4000 |     |  type = 0x3000 |     |  type = 0x3000 |
 *   4   |                |     |                |     |                |
 *       |  next = Entry4 |     |  next = 0      |     |  next = 0      |
 *       | value = 2323   |     | value = 0      |     | value = 0      |
 *       |________________|     |________________|     |________________|
 *
 * Once the cast array has been initialized, we use cast[0]->next field to link
 * it into the list of cast arrays for the type.
 *              ____    ____    ____
 * type->cast->|next|->|next|->|next|->0
 *             |----|  |----|  |----|
 *             |----|  |----|  |----|
 *             |----|  |----|  |----|
 *
 * Subsequent cast resolution works as follows:
 *
 * 1. Check whether the type matches the first entry in the current cast array.
 * 2. If not, then do a binary search over the (0:cast->value] interval using
 *    either type address or the hash value of the type name.
 * 3. If not found, then move over to the next cast array (cast[0]->next).
 *
 * ----------------------------------------------------------------------------- */

#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

/*
 * Sort function that puts cast entries with nonzero 'next' at the front
 * of the array while ordering them by addresses of their 'type' structs.
 */
SWIGINTERN int SWIG_CastCmpStruct(const void *pa, const void *pb) {
  swig_cast_info *pca = (swig_cast_info *)pa;
  swig_cast_info *pcb = (swig_cast_info *)pb;
  /* Entries with next != 0 (newly mapped) come before entries with next == 0 (already loaded) */
  if (!pca->next && pcb->next) return 1;
  if (pca->next && !pcb->next) return -1;
  /* Within the same group, sort by type pointer for binary search */
  if (pca->type < pcb->type) return -1;
  if (pca->type > pcb->type) return 1;
  return 0;
}

/*
 * Shell-sort 'next' and 'value' field pairs to order them by 'value'.
 */
SWIGINTERN void SWIG_CastHashSort(swig_cast_info *cast, int size) {
  const int hmax = size/9;
  int h, i;
  for(h = 1; h <= hmax; h = 3*h+1);
  for(; h > 0; h /= 3)
  {
    for(i = h; i < size; ++i)
    {
      swig_cast_info *p = cast[i].next;
      unsigned int hash = cast[i].value;
      int j = i;
      while(j >= h && hash < cast[j-h].value)
      {
        cast[j].next = cast[j-h].next;
        cast[j].value = cast[j-h].value;
        j -= h;
      }
      cast[j].next = p;
      cast[j].value = hash;
    }
  }
}

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 *target_type;
    swig_cast_info *cast, *first;
    int num_mapped = 0;
    
#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 = first = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      target_type = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        target_type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
        if (target_type) {
          /* Target type already defined in another module */
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: found cast %s\n", target_type->name);
#endif
          if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
            printf("SWIG_InitializeModule: skip old type %s\n", target_type->name);
#endif
            cast->type = target_type;
            target_type = 0;
          } else {
            /* Check if this cast is already in the list */
            swig_cast_info *ocast = SWIG_TypeCheck(target_type->name, type);
#ifdef SWIGRUNTIME_DEBUG
            if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", target_type->name);
#endif
            if (!ocast) {
              cast->type = target_type;
              target_type = 0;
            }
          }
        }
      }
      
      if (!target_type) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        /* Set inclusion mark for sorting */
        cast->next = cast;
        num_mapped++;
        
        if (type == cast->type) {
#ifdef SWIGRUNTIME_DEBUG
          printf("%s : self cast at pos [%li]\n", type->name, cast - first);
#endif
          if (cast - first) {
            /* Move cast to itself to the first entry in the array */
            
            swig_cast_info tmp = *cast;
            *cast = *first;
            *first = tmp;
          }
          first++;
          
        } else {
          cast->value = SWIG_Hash(cast->type->name, (unsigned int)strlen(cast->type->name));
        }
      }
      cast++;
    }
    
    if (num_mapped) {
      if (cast - first) {
        swig_cast_info *tmp;
        
        /* Sort casts by type address for binary search in SWIG_TypeCheckStruct */
        qsort(first, (size_t)(cast - first), sizeof(swig_cast_info), SWIG_CastCmpStruct);
        
        /* Remap back links for added entries */
        cast = swig_module.cast_initial[i] + num_mapped;
        for (tmp = first; tmp < cast; tmp++) {
          tmp->next = tmp;
        }
      }
      
      /* Set the value field of the first entry to the index of the last added entry */
      cast = swig_module.cast_initial[i];
      cast->value = (unsigned int)(num_mapped - 1);
      
      num_mapped -= (int)(first - cast);
      if (num_mapped > 1) {
        /* Sort <'next','value'> pairs by 'value' for binary search in SWIG_TypeCheck */
        
        SWIG_CastHashSort(first, num_mapped);
      }
      
      first = type->cast;
      if (first) {
        /* Link the current set into the list of cast arrays */
        cast->next = first->next;
        first->next = cast;
      } else {
        cast->next = 0;
        type->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;
  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) {
      swig_cast_info *head, *cast;
      head = swig_module.types[i]->cast;
      while (head) {
        for (cast = head; (cast - head) <= head->value; cast++) {
          if (!cast->converter) {
            if (cast->type && !cast->type->clientdata)
            SWIG_TypeClientData(cast->type, swig_module.types[i]->clientdata);
          }
        }
        head = head->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, (size_t)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 = (size_t)((ci->ptype) - types);
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (size_t)(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
 * -----------------------------------------------------------------------------*/

SWIGINTERN int SWIG_mod_exec(PyObject *module);

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
PyObject*
SWIG_init(void) {
  static PyModuleDef_Slot SwigSlots[] = {
    {
      Py_mod_exec, (void *)SWIG_mod_exec 
    },
#ifdef SWIGPYTHON_NOGIL
#ifdef Py_GIL_DISABLED
    {
      Py_mod_gil, Py_MOD_GIL_NOT_USED 
    },
#endif
#endif
    {
      0, NULL 
    }
  };
  
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    SWIG_name,
    NULL,
    0,
    SwigMethods,
    SwigSlots,
    NULL,
    NULL,
    NULL
  };
  
  return PyModuleDef_Init(&SWIG_module);
}

SWIGINTERN int SWIG_mod_exec(PyObject *m) {
  PyObject *d, *md, *globals;
  
#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_Type();
  assert(metatype);
  
  SwigPyStaticVar_Type();
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_runtime_data_module();
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_Type();
  SwigVarLink_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);
  
#ifdef SWIGPYTHON_NOGIL
#ifdef Py_GIL_DISABLED
  PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
#endif
#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.");
    return -1;
  }
  
  /* 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);
  
  
  _pyagrum_import_numpy();
  
  globals = SWIG_globals();
  if (!globals) {
    PyErr_SetString(PyExc_TypeError, "Failure to create SWIG globals.");
    return -1;
  }
  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, "EdgeMark_Circle",SWIG_From_int(static_cast< int >(gum::EdgeMark::Circle)));
  SWIG_Python_SetConstant(d, "EdgeMark_Tail",SWIG_From_int(static_cast< int >(gum::EdgeMark::Tail)));
  SWIG_Python_SetConstant(d, "EdgeMark_Arrowhead",SWIG_From_int(static_cast< int >(gum::EdgeMark::Arrowhead)));
  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);
  return 0;
}

