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


#ifndef SWIGPYTHON
#define SWIGPYTHON
#endif

#define SWIG_PYTHON_DIRECTOR_NO_VTABLE

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

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

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

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


/*
   Flags/methods for returning states.

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

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

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

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

   Now you can be more explicit:

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

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

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

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

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

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

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

       int food(double)
       int fooi(int);

   and you call

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

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

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

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

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


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#ifdef __cplusplus
}
#endif

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



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

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

#endif

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

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

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


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

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


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

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

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

#ifndef SWIG_PYBUFFER_SIZE
# define SWIG_PYBUFFER_SIZE 1024
#endif

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

#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

#ifdef __cplusplus
extern "C" {
#endif

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

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

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


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

#ifdef __cplusplus
}
#endif


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

/* Common SWIG API */

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

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

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

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

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

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

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

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


/* Runtime API */

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

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


/* Runtime API implementation */

/* Error manipulation */

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

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

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

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

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

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

#else

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

#endif

/* Append a value to the result obj */

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

/* Unpack the argument tuple */

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

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

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

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

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

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

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

#ifdef __cplusplus
extern "C" {
#endif

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

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

/* The python void return value */

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

/* SwigPyClientData */

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

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

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


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

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

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

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


#ifdef SWIGPYTHON_BUILTIN

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

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

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

#endif

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

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

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

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

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

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

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


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

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

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

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

SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  PyObject *next = sobj->next;
  if (sobj->own == SWIG_POINTER_OWN) {
    swig_type_info *ty = sobj->ty;
    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    PyObject *destroy = data ? data->destroy : 0;
    if (destroy) {
      /* destroy is always a VARARGS method */
      PyObject *res;

      /* PyObject_CallFunction() has the potential to silently drop
         the active 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 *val = NULL, *type = NULL, *tb = NULL;
      PyErr_Fetch(&val, &type, &tb);

      if (data->delargs) {
        /* we need to create a temporary object to carry the destroy operation */
        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
        res = SWIG_Python_CallFunctor(destroy, tmp);
        Py_DECREF(tmp);
      } else {
        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
        PyObject *mself = PyCFunction_GET_SELF(destroy);
        res = ((*meth)(mself, v));
      }
      if (!res)
        PyErr_WriteUnraisable(destroy);

      PyErr_Restore(val, type, tb);

      Py_XDECREF(res);
    } 
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    else {
      const char *name = SWIG_TypePrettyName(ty);
      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    }
#endif
  } 
  Py_XDECREF(next);
  PyObject_DEL(v);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

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

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

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

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

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

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

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

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

static PyObject *swig_this = NULL;

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

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

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

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

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

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

  obj = 0;

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

/* Acquire a pointer value */

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

/* Convert a pointer value */

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

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

  res = SWIG_ERROR;

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

/* Convert a function ptr value */

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

/* Convert a packed value value */

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

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

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

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

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


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

/* Create a new pointer object */

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

  if (!ptr)
    return SWIG_Py_Void();

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

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

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

/* Create a new packed object */

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


#ifdef __cplusplus
}
#endif



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

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



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

#define SWIGTYPE_p_BayesRule swig_types[0]
#define SWIGTYPE_p_BoundingBox swig_types[1]
#define SWIGTYPE_p_C3Approx swig_types[2]
#define SWIGTYPE_p_C3SobolSensitivity swig_types[3]
#define SWIGTYPE_p_CVOptGrid swig_types[4]
#define SWIGTYPE_p_Cpair swig_types[5]
#define SWIGTYPE_p_CrossIndex swig_types[6]
#define SWIGTYPE_p_CrossNode swig_types[7]
#define SWIGTYPE_p_CrossValidate swig_types[8]
#define SWIGTYPE_p_Data swig_types[9]
#define SWIGTYPE_p_DmDiff swig_types[10]
#define SWIGTYPE_p_DmProd swig_types[11]
#define SWIGTYPE_p_FILE swig_types[12]
#define SWIGTYPE_p_FT1DArray swig_types[13]
#define SWIGTYPE_p_FTMemSpace swig_types[14]
#define SWIGTYPE_p_FTRegress swig_types[15]
#define SWIGTYPE_p_FTparam swig_types[16]
#define SWIGTYPE_p_FiberCut swig_types[17]
#define SWIGTYPE_p_FiberOptArgs swig_types[18]
#define SWIGTYPE_p_FtCrossArgs swig_types[19]
#define SWIGTYPE_p_FunctionMonitor swig_types[20]
#define SWIGTYPE_p_FunctionTrain swig_types[21]
#define SWIGTYPE_p_Fwrap swig_types[22]
#define SWIGTYPE_p_GenericFunction swig_types[23]
#define SWIGTYPE_p_HashtableCpair swig_types[24]
#define SWIGTYPE_p_Kernel swig_types[25]
#define SWIGTYPE_p_KernelApproxOpts swig_types[26]
#define SWIGTYPE_p_KernelExpansion swig_types[27]
#define SWIGTYPE_p_LeastSquaresArgs swig_types[28]
#define SWIGTYPE_p_Likelihood swig_types[29]
#define SWIGTYPE_p_LinElemExp swig_types[30]
#define SWIGTYPE_p_LinElemExpAopts swig_types[31]
#define SWIGTYPE_p_LinElemXY swig_types[32]
#define SWIGTYPE_p_LinearTransform swig_types[33]
#define SWIGTYPE_p_MultiApproxOpts swig_types[34]
#define SWIGTYPE_p_ObjectiveFunction swig_types[35]
#define SWIGTYPE_p_OneApproxOpts swig_types[36]
#define SWIGTYPE_p_OpeOpts swig_types[37]
#define SWIGTYPE_p_Operator swig_types[38]
#define SWIGTYPE_p_OrthPoly swig_types[39]
#define SWIGTYPE_p_OrthPolyExpansion swig_types[40]
#define SWIGTYPE_p_PairList swig_types[41]
#define SWIGTYPE_p_PiecewisePoly swig_types[42]
#define SWIGTYPE_p_Pivot swig_types[43]
#define SWIGTYPE_p_PivotSet swig_types[44]
#define SWIGTYPE_p_ProbabilityDensity swig_types[45]
#define SWIGTYPE_p_PwPolyOpts swig_types[46]
#define SWIGTYPE_p_QR swig_types[47]
#define SWIGTYPE_p_Qmarray swig_types[48]
#define SWIGTYPE_p_Quasimatrix swig_types[49]
#define SWIGTYPE_p_Regress1DOpts swig_types[50]
#define SWIGTYPE_p_RegressOpts swig_types[51]
#define SWIGTYPE_p_SLMemManager swig_types[52]
#define SWIGTYPE_p_SLP swig_types[53]
#define SWIGTYPE_p_SpaceMapping swig_types[54]
#define SWIGTYPE_p_StandardPoly swig_types[55]
#define SWIGTYPE_p_c3Opt swig_types[56]
#define SWIGTYPE_p_c3Vector swig_types[57]
#define SWIGTYPE_p_c3opt_lbfgs_list swig_types[58]
#define SWIGTYPE_p_char swig_types[59]
#define SWIGTYPE_p_double swig_types[60]
#define SWIGTYPE_p_double_complex swig_types[61]
#define SWIGTYPE_p_f_char_unsigned_long_unsigned_long_p_double_p_p_struct_Qmarray_p_void__void swig_types[62]
#define SWIGTYPE_p_f_double_double_p_void__double swig_types[63]
#define SWIGTYPE_p_f_double_p_void__double swig_types[64]
#define SWIGTYPE_p_f_double_unsigned_long_p_unsigned_long_p_void__void swig_types[65]
#define SWIGTYPE_p_f_int_int_int_p_void__double swig_types[66]
#define SWIGTYPE_p_f_p_double_double_unsigned_long_unsigned_long_p_double_p_void__int swig_types[67]
#define SWIGTYPE_p_f_p_double_p_double_p_void__int swig_types[68]
#define SWIGTYPE_p_f_p_double_p_void__double swig_types[69]
#define SWIGTYPE_p_f_p_double_p_void__p_double swig_types[70]
#define SWIGTYPE_p_f_p_q_const__double_p_void__double swig_types[71]
#define SWIGTYPE_p_f_p_q_const__struct_GenericFunction_p_void__p_GenericFunction swig_types[72]
#define SWIGTYPE_p_f_p_q_const__unsigned_long_p_void__double swig_types[73]
#define SWIGTYPE_p_f_unsigned_long__double swig_types[74]
#define SWIGTYPE_p_f_unsigned_long_p_q_const__double_p_double_p_void__double swig_types[75]
#define SWIGTYPE_p_f_unsigned_long_p_q_const__double_p_double_p_void__int swig_types[76]
#define SWIGTYPE_p_f_unsigned_long_p_q_const__double_p_double_unsigned_long_p_unsigned_long_p_struct_Data_p_struct_SLMemManager_p_void__double swig_types[77]
#define SWIGTYPE_p_f_unsigned_long_p_q_const__double_unsigned_long_p_unsigned_long_p_struct_SLMemManager_p_struct_Data_p_p_double_p_p_double_p_void__int swig_types[78]
#define SWIGTYPE_p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__double swig_types[79]
#define SWIGTYPE_p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__int swig_types[80]
#define SWIGTYPE_p_ff swig_types[81]
#define SWIGTYPE_p_fiber_info swig_types[82]
#define SWIGTYPE_p_fiber_list swig_types[83]
#define SWIGTYPE_p_func_type swig_types[84]
#define SWIGTYPE_p_function_class swig_types[85]
#define SWIGTYPE_p_int swig_types[86]
#define SWIGTYPE_p_long_double swig_types[87]
#define SWIGTYPE_p_mat swig_types[88]
#define SWIGTYPE_p_p_CrossIndex swig_types[89]
#define SWIGTYPE_p_p_FT1DArray swig_types[90]
#define SWIGTYPE_p_p_FTMemSpace swig_types[91]
#define SWIGTYPE_p_p_FiberCut swig_types[92]
#define SWIGTYPE_p_p_FunctionTrain swig_types[93]
#define SWIGTYPE_p_p_GenericFunction swig_types[94]
#define SWIGTYPE_p_p_KernelExpansion swig_types[95]
#define SWIGTYPE_p_p_LinElemExp swig_types[96]
#define SWIGTYPE_p_p_LinElemExpAopts swig_types[97]
#define SWIGTYPE_p_p_LinElemXY swig_types[98]
#define SWIGTYPE_p_p_LinearTransform swig_types[99]
#define SWIGTYPE_p_p_MultiApproxOpts swig_types[100]
#define SWIGTYPE_p_p_ObjectiveFunction swig_types[101]
#define SWIGTYPE_p_p_OneApproxOpts swig_types[102]
#define SWIGTYPE_p_p_OpeOpts swig_types[103]
#define SWIGTYPE_p_p_Operator swig_types[104]
#define SWIGTYPE_p_p_OrthPolyExpansion swig_types[105]
#define SWIGTYPE_p_p_PairList swig_types[106]
#define SWIGTYPE_p_p_PiecewisePoly swig_types[107]
#define SWIGTYPE_p_p_ProbabilityDensity swig_types[108]
#define SWIGTYPE_p_p_PwPolyOpts swig_types[109]
#define SWIGTYPE_p_p_QR swig_types[110]
#define SWIGTYPE_p_p_Qmarray swig_types[111]
#define SWIGTYPE_p_p_Quasimatrix swig_types[112]
#define SWIGTYPE_p_p_c3Vector swig_types[113]
#define SWIGTYPE_p_p_char swig_types[114]
#define SWIGTYPE_p_p_double swig_types[115]
#define SWIGTYPE_p_p_fiber_list swig_types[116]
#define SWIGTYPE_p_p_mat swig_types[117]
#define SWIGTYPE_p_p_p_GenericFunction swig_types[118]
#define SWIGTYPE_p_p_sk_decomp swig_types[119]
#define SWIGTYPE_p_p_storevals swig_types[120]
#define SWIGTYPE_p_p_void swig_types[121]
#define SWIGTYPE_p_sk_decomp swig_types[122]
#define SWIGTYPE_p_storevals swig_types[123]
#define SWIGTYPE_p_storevals_main swig_types[124]
#define SWIGTYPE_p_unsigned_char swig_types[125]
#define SWIGTYPE_p_unsigned_long swig_types[126]
#define SWIGTYPE_p_void swig_types[127]
static swig_type_info *swig_types[129];
static swig_module_info swig_module = {swig_types, 128, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

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

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

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

#else
#  define SWIG_init    init_c3

#endif
#define SWIG_name    "_c3"

#define SWIGVERSION 0x030012 
#define SWIG_VERSION SWIGVERSION


#define SWIG_as_voidptr(a) (void *)((const void *)(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) 


    #define SWIG_FILE_WITH_INIT

    #include <Python.h>
/*     #include "lib_interface/approximate.h" */
/*     #include "lib_array/array.h" */
    
/* #include "lib_stringmanip/stringmanip.h" */
/* #include "lib_superlearn/regress.h" */
/* #include "lib_superlearn/learning_options.h" */
/* #include "lib_superlearn/objective_functions.h" */
/* #include "lib_superlearn/parameterization.h" */
/* #include "lib_superlearn/superlearn.h" */
/* #include "lib_interface/c3_interface.h" */
/* #include "lib_clinalg/diffusion.h" */
/* #include "lib_clinalg/dmrg.h" */
/* #include "lib_clinalg/dmrgprod.h" */
/* #include "lib_clinalg/ft.h" */
/* #include "lib_clinalg/indmanage.h" */
/* #include "lib_clinalg/lib_clinalg.h" */
/* #include "lib_clinalg/qmarray.h" */
/* #include "lib_clinalg/quasimatrix.h" */
/* #include "lib_funcs/fapprox.h" */
/* #include "lib_funcs/functions.h" */
/* #include "lib_funcs/fwrap.h" */
/* #include "lib_funcs/hpoly.h" */
/* #include "lib_funcs/legtens.h" */
/* #include "lib_funcs/lib_funcs.h" */
/* #include "lib_funcs/linelm.h" */
/* #include "lib_funcs/kernels.h" */
/* #include "lib_funcs/monitoring.h" */
/* #include "lib_funcs/piecewisepoly.h" */
/* #include "lib_funcs/pivoting.h" */
/* #include "lib_funcs/polynomials.h" */
/* #include "lib_funcs/space.h" */
/* #include "lib_linalg/lib_linalg.h" */
/* #include "lib_linalg/linalg.h" */
/* #include "lib_linalg/matrix_util.h" */
/* #include "lib_optimization/lib_optimization.h" */
/* #include "lib_optimization/optimization.h" */
/* #include "lib_probability/lib_probability.h" */
/* #include "lib_probability/probability.h" */
/* #include "lib_quadrature/quadrature.h" */
         
    #include "approximate.h"
    #include "array.h"
    #include "stringmanip.h"
    #include "regress.h"
    #include "learning_options.h"
    #include "objective_functions.h"
    #include "parameterization.h"
    #include "superlearn.h"
    #include "regress.h"
    #include "c3_interface.h"
    #include "diffusion.h"
    #include "dmrg.h"
    #include "dmrgprod.h"
    #include "ft.h"
    #include "indmanage.h"
    #include "lib_clinalg.h"
    #include "qmarray.h"
    #include "quasimatrix.h"
    /* #include "fft.h" */
    #include "fapprox.h"
    #include "functions.h"
    #include "fwrap.h"
    #include "hpoly.h"
    #include "legtens.h"
    #include "lib_funcs.h"
    #include "linelm.h"
    #include "kernels.h"
    #include "monitoring.h"
    #include "piecewisepoly.h"
    #include "pivoting.h"
    #include "polynomials.h"
    /* #include "fourier.h"     */
    #include "space.h"
    #include "lib_linalg.h"
    #include "linalg.h"
    #include "matrix_util.h"
    #include "lib_optimization.h"
    #include "probability.h"
    #include "lib_probability.h"
    #include "optimization.h"
    #include "quadrature.h"

    int c3py_wrapped_eval(size_t N, const double * x, double * out, void * args);
    void fwrap_set_pyfunc(struct Fwrap *, PyObject *);

    typedef long unsigned int size_t;


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


#include <float.h>


#include <math.h>


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


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


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


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


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
      if (val) *val = (unsigned long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = (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 = (size_t)(v);
  }
#endif
  return res;
}


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


#ifndef SWIG_FILE_WITH_INIT
#  define NO_IMPORT_ARRAY
#endif
#include "stdio.h"
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#include <numpy/arrayobject.h>


    struct FunctionTrain * my_ft_regress_run(struct FTRegress * ftr ,struct c3Opt * opt ,size_t len1, const double* xdata, size_t len2, const double * ydata){
        if (len1 != len2*ft_regress_get_dim(ftr)){
            PyErr_Format(PyExc_ValueError,
                         "Arrays of lengths (%zu,%zu) given",
                         len1, len2);
            return NULL;
        }
        return ft_regress_run(ftr,opt,len2,xdata,ydata);
    }


#if NPY_API_VERSION < 0x00000007
#define NPY_ARRAY_DEFAULT NPY_DEFAULT
#define NPY_ARRAY_FARRAY  NPY_FARRAY
#define NPY_FORTRANORDER  NPY_FORTRAN
#endif


/* Macros to extract array attributes.
 */
#if NPY_API_VERSION < 0x00000007
#define is_array(a)            ((a) && PyArray_Check((PyArrayObject*)a))
#define array_type(a)          (int)(PyArray_TYPE((PyArrayObject*)a))
#define array_numdims(a)       (((PyArrayObject*)a)->nd)
#define array_dimensions(a)    (((PyArrayObject*)a)->dimensions)
#define array_size(a,i)        (((PyArrayObject*)a)->dimensions[i])
#define array_strides(a)       (((PyArrayObject*)a)->strides)
#define array_stride(a,i)      (((PyArrayObject*)a)->strides[i])
#define array_data(a)          (((PyArrayObject*)a)->data)
#define array_descr(a)         (((PyArrayObject*)a)->descr)
#define array_flags(a)         (((PyArrayObject*)a)->flags)
#define array_enableflags(a,f) (((PyArrayObject*)a)->flags) = f
#else
#define is_array(a)            ((a) && PyArray_Check(a))
#define array_type(a)          PyArray_TYPE((PyArrayObject*)a)
#define array_numdims(a)       PyArray_NDIM((PyArrayObject*)a)
#define array_dimensions(a)    PyArray_DIMS((PyArrayObject*)a)
#define array_strides(a)       PyArray_STRIDES((PyArrayObject*)a)
#define array_stride(a,i)      PyArray_STRIDE((PyArrayObject*)a,i)
#define array_size(a,i)        PyArray_DIM((PyArrayObject*)a,i)
#define array_data(a)          PyArray_DATA((PyArrayObject*)a)
#define array_descr(a)         PyArray_DESCR((PyArrayObject*)a)
#define array_flags(a)         PyArray_FLAGS((PyArrayObject*)a)
#define array_enableflags(a,f) PyArray_ENABLEFLAGS((PyArrayObject*)a,f)
#endif
#define array_is_contiguous(a) (PyArray_ISCONTIGUOUS((PyArrayObject*)a))
#define array_is_native(a)     (PyArray_ISNOTSWAPPED((PyArrayObject*)a))
#define array_is_fortran(a)    (PyArray_ISFORTRAN((PyArrayObject*)a))


  /* Given a PyObject, return a string describing its type.
   */
  const char* pytype_string(PyObject* py_obj)
  {
    if (py_obj == NULL          ) return "C NULL value";
    if (py_obj == Py_None       ) return "Python None" ;
    if (PyCallable_Check(py_obj)) return "callable"    ;
    if (PyString_Check(  py_obj)) return "string"      ;
    if (PyInt_Check(     py_obj)) return "int"         ;
    if (PyFloat_Check(   py_obj)) return "float"       ;
    if (PyDict_Check(    py_obj)) return "dict"        ;
    if (PyList_Check(    py_obj)) return "list"        ;
    if (PyTuple_Check(   py_obj)) return "tuple"       ;
#if PY_MAJOR_VERSION < 3
    if (PyFile_Check(    py_obj)) return "file"        ;
    if (PyModule_Check(  py_obj)) return "module"      ;
    if (PyInstance_Check(py_obj)) return "instance"    ;
#endif

    return "unkown type";
  }

  /* Given a NumPy typecode, return a string describing the type.
   */
  const char* typecode_string(int typecode)
  {
    static const char* type_names[25] = {"bool",
                                         "byte",
                                         "unsigned byte",
                                         "short",
                                         "unsigned short",
                                         "int",
                                         "unsigned int",
                                         "long",
                                         "unsigned long",
                                         "long long",
                                         "unsigned long long",
                                         "float",
                                         "double",
                                         "long double",
                                         "complex float",
                                         "complex double",
                                         "complex long double",
                                         "object",
                                         "string",
                                         "unicode",
                                         "void",
                                         "ntypes",
                                         "notype",
                                         "char",
                                         "unknown"};
    return typecode < 24 ? type_names[typecode] : type_names[24];
  }

  /* Make sure input has correct numpy type.  This now just calls
     PyArray_EquivTypenums().
   */
  int type_match(int actual_type,
                 int desired_type)
  {
    return PyArray_EquivTypenums(actual_type, desired_type);
  }


  /* Given a PyObject pointer, cast it to a PyArrayObject pointer if
   * legal.  If not, set the python error string appropriately and
   * return NULL.
   */
  PyArrayObject* obj_to_array_no_conversion(PyObject* input,
                                            int        typecode)
  {
    PyArrayObject* ary = NULL;
    if (is_array(input) && (typecode == NPY_NOTYPE ||
                            PyArray_EquivTypenums(array_type(input), typecode)))
    {
      ary = (PyArrayObject*) input;
    }
    else if is_array(input)
    {
      const char* desired_type = typecode_string(typecode);
      const char* actual_type  = typecode_string(array_type(input));
      PyErr_Format(PyExc_TypeError,
                   "Array of type '%s' required.  Array of type '%s' given",
                   desired_type, actual_type);
      ary = NULL;
    }
    else
    {
      const char* desired_type = typecode_string(typecode);
      const char* actual_type  = pytype_string(input);
      PyErr_Format(PyExc_TypeError,
                   "Array of type '%s' required.  A '%s' was given",
                   desired_type,
                   actual_type);
      ary = NULL;
    }
    return ary;
  }

  /* Convert the given PyObject to a NumPy array with the given
   * typecode.  On success, return a valid PyArrayObject* with the
   * correct type.  On failure, the python error string will be set and
   * the routine returns NULL.
   */
  PyArrayObject* obj_to_array_allow_conversion(PyObject* input,
                                               int       typecode,
                                               int*      is_new_object)
  {
    PyArrayObject* ary = NULL;
    PyObject*      py_obj;
    if (is_array(input) && (typecode == NPY_NOTYPE ||
                            PyArray_EquivTypenums(array_type(input),typecode)))
    {
      ary = (PyArrayObject*) input;
      *is_new_object = 0;
    }
    else
    {
      py_obj = PyArray_FROMANY(input, typecode, 0, 0, NPY_ARRAY_DEFAULT);
      /* If NULL, PyArray_FromObject will have set python error value.*/
      ary = (PyArrayObject*) py_obj;
      *is_new_object = 1;
    }
    return ary;
  }

  /* Given a PyArrayObject, check to see if it is contiguous.  If so,
   * return the input pointer and flag it as not a new object.  If it is
   * not contiguous, create a new PyArrayObject using the original data,
   * flag it as a new object and return the pointer.
   */
  PyArrayObject* make_contiguous(PyArrayObject* ary,
                                 int*           is_new_object,
                                 int            min_dims,
                                 int            max_dims)
  {
    PyArrayObject* result;
    if (array_is_contiguous(ary))
    {
      result = ary;
      *is_new_object = 0;
    }
    else
    {
      result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary,
                                                              array_type(ary),
                                                              min_dims,
                                                              max_dims);
      *is_new_object = 1;
    }
    return result;
  }

  /* Given a PyArrayObject, check to see if it is Fortran-contiguous.
   * If so, return the input pointer, but do not flag it as not a new
   * object.  If it is not Fortran-contiguous, create a new
   * PyArrayObject using the original data, flag it as a new object
   * and return the pointer.
   */
  PyArrayObject* make_fortran(PyArrayObject* ary,
                              int*           is_new_object)
  {
    PyArrayObject* result;
    if (array_is_fortran(ary))
    {
      result = ary;
      *is_new_object = 0;
    }
    else
    {
      Py_INCREF(array_descr(ary));
      result = (PyArrayObject*) PyArray_FromArray(ary,
                                                  array_descr(ary),
                                                  NPY_FORTRANORDER);
      *is_new_object = 1;
    }
    return result;
  }

  /* Convert a given PyObject to a contiguous PyArrayObject of the
   * specified type.  If the input object is not a contiguous
   * PyArrayObject, a new one will be created and the new object flag
   * will be set.
   */
  PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input,
                                                          int       typecode,
                                                          int*      is_new_object)
  {
    int is_new1 = 0;
    int is_new2 = 0;
    PyArrayObject* ary2;
    PyArrayObject* ary1 = obj_to_array_allow_conversion(input,
                                                        typecode,
                                                        &is_new1);
    if (ary1)
    {
      ary2 = make_contiguous(ary1, &is_new2, 0, 0);
      if ( is_new1 && is_new2)
      {
        Py_DECREF(ary1);
      }
      ary1 = ary2;
    }
    *is_new_object = is_new1 || is_new2;
    return ary1;
  }

  /* Convert a given PyObject to a Fortran-ordered PyArrayObject of the
   * specified type.  If the input object is not a Fortran-ordered
   * PyArrayObject, a new one will be created and the new object flag
   * will be set.
   */
  PyArrayObject* obj_to_array_fortran_allow_conversion(PyObject* input,
                                                       int       typecode,
                                                       int*      is_new_object)
  {
    int is_new1 = 0;
    int is_new2 = 0;
    PyArrayObject* ary2;
    PyArrayObject* ary1 = obj_to_array_allow_conversion(input,
                                                        typecode,
                                                        &is_new1);
    if (ary1)
    {
      ary2 = make_fortran(ary1, &is_new2);
      if (is_new1 && is_new2)
      {
        Py_DECREF(ary1);
      }
      ary1 = ary2;
    }
    *is_new_object = is_new1 || is_new2;
    return ary1;
  }


  /* Test whether a python object is contiguous.  If array is
   * contiguous, return 1.  Otherwise, set the python error string and
   * return 0.
   */
  int require_contiguous(PyArrayObject* ary)
  {
    int contiguous = 1;
    if (!array_is_contiguous(ary))
    {
      PyErr_SetString(PyExc_TypeError,
                      "Array must be contiguous.  A non-contiguous array was given");
      contiguous = 0;
    }
    return contiguous;
  }

  /* Require that a numpy array is not byte-swapped.  If the array is
   * not byte-swapped, return 1.  Otherwise, set the python error string
   * and return 0.
   */
  int require_native(PyArrayObject* ary)
  {
    int native = 1;
    if (!array_is_native(ary))
    {
      PyErr_SetString(PyExc_TypeError,
                      "Array must have native byteorder.  "
                      "A byte-swapped array was given");
      native = 0;
    }
    return native;
  }

  /* Require the given PyArrayObject to have a specified number of
   * dimensions.  If the array has the specified number of dimensions,
   * return 1.  Otherwise, set the python error string and return 0.
   */
  int require_dimensions(PyArrayObject* ary,
                         int            exact_dimensions)
  {
    int success = 1;
    if (array_numdims(ary) != exact_dimensions)
    {
      PyErr_Format(PyExc_TypeError,
                   "Array must have %d dimensions.  Given array has %d dimensions",
                   exact_dimensions,
                   array_numdims(ary));
      success = 0;
    }
    return success;
  }

  /* Require the given PyArrayObject to have one of a list of specified
   * number of dimensions.  If the array has one of the specified number
   * of dimensions, return 1.  Otherwise, set the python error string
   * and return 0.
   */
  int require_dimensions_n(PyArrayObject* ary,
                           int*           exact_dimensions,
                           int            n)
  {
    int success = 0;
    int i;
    char dims_str[255] = "";
    char s[255];
    for (i = 0; i < n && !success; i++)
    {
      if (array_numdims(ary) == exact_dimensions[i])
      {
        success = 1;
      }
    }
    if (!success)
    {
      for (i = 0; i < n-1; i++)
      {
        sprintf(s, "%d, ", exact_dimensions[i]);
        strcat(dims_str,s);
      }
      sprintf(s, " or %d", exact_dimensions[n-1]);
      strcat(dims_str,s);
      PyErr_Format(PyExc_TypeError,
                   "Array must have %s dimensions.  Given array has %d dimensions",
                   dims_str,
                   array_numdims(ary));
    }
    return success;
  }

  /* Require the given PyArrayObject to have a specified shape.  If the
   * array has the specified shape, return 1.  Otherwise, set the python
   * error string and return 0.
   */
  int require_size(PyArrayObject* ary,
                   npy_intp*      size,
                   int            n)
  {
    int i;
    int success = 1;
    int len;
    char desired_dims[255] = "[";
    char s[255];
    char actual_dims[255] = "[";
    for(i=0; i < n;i++)
    {
      if (size[i] != -1 &&  size[i] != array_size(ary,i))
      {
        success = 0;
      }
    }
    if (!success)
    {
      for (i = 0; i < n; i++)
      {
        if (size[i] == -1)
        {
          sprintf(s, "*,");
        }
        else
        {
          sprintf(s, "%ld,", (long int)size[i]);
        }
        strcat(desired_dims,s);
      }
      len = strlen(desired_dims);
      desired_dims[len-1] = ']';
      for (i = 0; i < n; i++)
      {
        sprintf(s, "%ld,", (long int)array_size(ary,i));
        strcat(actual_dims,s);
      }
      len = strlen(actual_dims);
      actual_dims[len-1] = ']';
      PyErr_Format(PyExc_TypeError,
                   "Array must have shape of %s.  Given array has shape of %s",
                   desired_dims,
                   actual_dims);
    }
    return success;
  }

  /* Require the given PyArrayObject to to be Fortran ordered.  If the
   * the PyArrayObject is already Fortran ordered, do nothing.  Else,
   * set the Fortran ordering flag and recompute the strides.
   */
  int require_fortran(PyArrayObject* ary)
  {
    int success = 1;
    int nd = array_numdims(ary);
    int i;
    npy_intp * strides = array_strides(ary);
    if (array_is_fortran(ary)) return success;
    /* Set the Fortran ordered flag */
    array_enableflags(ary,NPY_ARRAY_FARRAY);
    /* Recompute the strides */
    strides[0] = strides[nd-1];
    for (i=1; i < nd; ++i)
      strides[i] = strides[i-1] * array_size(ary,i-1);
    return success;
  }




    struct CrossValidate * my_cross_validate_init(size_t dim, size_t len1, const double* xdata, size_t len2, const double * ydata,size_t kfold, int verbose){
        if (len1 != len2*dim){
            PyErr_Format(PyExc_ValueError,
                         "Arrays of lengths (%zu,%zu) given",
                         len1, len2);
            return NULL;
        }
        return cross_validate_init(len2,dim,xdata,ydata,kfold,verbose);
    }


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


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 = (int)(v);
    }
  }  
  return res;
}


    struct LinElemExpAopts * my_lin_elem_exp_aopts_alloc(size_t len1, const double* evalnd_pt){

      struct LinElemExpAopts * lexp = lin_elem_exp_aopts_alloc(len1,(double*)evalnd_pt);
      lin_elem_exp_aopts_set_nodes_copy(lexp,len1,evalnd_pt);
      return lexp;
    }


    double my_function_train_eval(struct FunctionTrain * ft ,size_t len1, const double* evalnd_pt){
        if (len1 != function_train_get_dim(ft)){
            PyErr_Format(PyExc_ValueError,
                         "Evaluation point has incorrect dimensions (%zu) instead of %zu",
                         len1,function_train_get_dim(ft));
            return 0.0;
        }
        return function_train_eval(ft,evalnd_pt);
    }


  #define SWIG_From_double   PyFloat_FromDouble 


    void my_function_train_gradient_eval(struct FunctionTrain * ft ,size_t len1, const double* evalnd_pt,
                                         size_t len2, double * evalnd_out){
        if (len1 != function_train_get_dim(ft)){
            PyErr_Format(PyExc_ValueError,
                         "Evaluation point has incorrect dimensions (%zu) instead of %zu",
                         len1,function_train_get_dim(ft));
        }
        if (len1 != len2){
            PyErr_Format(PyExc_ValueError,
                         "Input and outputs must be the same size: currently they are (%zu,%zu)",
                         len1,len2);
        }
        
        function_train_gradient_eval(ft,evalnd_pt,evalnd_out);

    }


  #define SWIG_From_long   PyInt_FromLong 


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


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLongLong(value) : PyInt_FromLong((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  ((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  ((unsigned long long)(value));
  }
#endif
}


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


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


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


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

	   The default behavior is just to return the pointer value,
	   so, be careful.
	*/ 
#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
	if (*alloc != SWIG_OLDOBJ) 
#else
	if (*alloc == SWIG_NEWOBJ) 
#endif
	{
	  *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
	  *alloc = SWIG_NEWOBJ;
	} else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      } else {
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
	*cptr = PyBytes_AsString(obj);
#else
	assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
	*cptr = SWIG_Python_str_AsChar(obj);
#endif
      }
    }
    if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    Py_XDECREF(obj);
#endif
    return SWIG_OK;
  } else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
    if (PyUnicode_Check(obj)) {
      char *cstr; Py_ssize_t len;
      if (!alloc && cptr) {
        return SWIG_RuntimeError;
      }
      obj = PyUnicode_AsUTF8String(obj);
      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
        if (cptr) {
          if (alloc) *alloc = SWIG_NEWOBJ;
          *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
        }
        if (psize) *psize = len + 1;

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

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





SWIGINTERN int
SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
{ 
  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
  if (SWIG_IsOK(res)) {
    /* special case of single char conversion when we don't need space for NUL */
    if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
    if (csize <= size) {
      if (val) {
	if (csize) memcpy(val, cptr, csize*sizeof(char));
	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
      }
      if (alloc == SWIG_NEWOBJ) {
	free((char*)cptr);
	res = SWIG_DelNewMask(res);
      }      
      return res;
    }
    if (alloc == SWIG_NEWOBJ) free((char*)cptr);
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_char (PyObject * obj, char *val)
{    
  int res = SWIG_AsCharArray(obj, val, 1);
  if (!SWIG_IsOK(res)) {
    long v;
    res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    if (SWIG_IsOK(res)) {
      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
	if (val) *val = (char)(v);
      } else {
	res = SWIG_OverflowError;
      }
    }
  }
  return res;
}


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

#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_c3py_wrapped_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  void *arg4 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:c3py_wrapped_eval",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3py_wrapped_eval" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3py_wrapped_eval" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3py_wrapped_eval" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "c3py_wrapped_eval" "', argument " "4"" of type '" "void *""'"); 
  }
  result = (int)c3py_wrapped_eval(arg1,(double const *)arg2,arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_set_pyfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fwrap_set_pyfunc",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_set_pyfunc" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  arg2 = obj1;
  fwrap_set_pyfunc(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_alloc",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "function_train_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct FunctionTrain *)function_train_alloc(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_free" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  function_train_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  struct c3Opt *arg2 = (struct c3Opt *) 0 ;
  size_t arg3 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  double *arg6 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyArrayObject *array3 = NULL ;
  int is_new_object3 = 0 ;
  PyArrayObject *array5 = NULL ;
  int is_new_object5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ft_regress_run",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_run" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_regress_run" "', argument " "2"" of type '" "struct c3Opt *""'"); 
  }
  arg2 = (struct c3Opt *)(argp2);
  {
    npy_intp size[1] = {
      -1
    };
    array3 = obj_to_array_contiguous_allow_conversion(obj2,
      NPY_DOUBLE,
      &is_new_object3);
    if (!array3 || !require_dimensions(array3, 1) ||
      !require_size(array3, size, 1)) SWIG_fail;
    arg3 = (int) array_size(array3,0);
    arg4 = (double*) array_data(array3);
  }
  {
    npy_intp size[1] = {
      -1
    };
    array5 = obj_to_array_contiguous_allow_conversion(obj3,
      NPY_DOUBLE,
      &is_new_object5);
    if (!array5 || !require_dimensions(array5, 1) ||
      !require_size(array5, size, 1)) SWIG_fail;
    arg5 = (int) array_size(array5,0);
    arg6 = (double*) array_data(array5);
  }
  {
    result = (struct FunctionTrain *)my_ft_regress_run(arg1,arg2,arg3,(double const *)arg4,arg5,(double const *)arg6);
    if (PyErr_Occurred()) SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  {
    if (is_new_object3 && array3)
    {
      Py_DECREF(array3); 
    }
  }
  {
    if (is_new_object5 && array5)
    {
      Py_DECREF(array5); 
    }
  }
  return resultobj;
fail:
  {
    if (is_new_object3 && array3)
    {
      Py_DECREF(array3); 
    }
  }
  {
    if (is_new_object5 && array5)
    {
      Py_DECREF(array5); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_validate_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  int arg7 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyArrayObject *array2 = NULL ;
  int is_new_object2 = 0 ;
  PyArrayObject *array4 = NULL ;
  int is_new_object4 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  struct CrossValidate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:cross_validate_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cross_validate_init" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  {
    npy_intp size[1] = {
      -1
    };
    array2 = obj_to_array_contiguous_allow_conversion(obj1,
      NPY_DOUBLE,
      &is_new_object2);
    if (!array2 || !require_dimensions(array2, 1) ||
      !require_size(array2, size, 1)) SWIG_fail;
    arg2 = (int) array_size(array2,0);
    arg3 = (double*) array_data(array2);
  }
  {
    npy_intp size[1] = {
      -1
    };
    array4 = obj_to_array_contiguous_allow_conversion(obj2,
      NPY_DOUBLE,
      &is_new_object4);
    if (!array4 || !require_dimensions(array4, 1) ||
      !require_size(array4, size, 1)) SWIG_fail;
    arg4 = (int) array_size(array4,0);
    arg5 = (double*) array_data(array4);
  }
  ecode6 = SWIG_AsVal_size_t(obj3, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cross_validate_init" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  ecode7 = SWIG_AsVal_int(obj4, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cross_validate_init" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = (int)(val7);
  {
    result = (struct CrossValidate *)my_cross_validate_init(arg1,arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,arg7);
    if (PyErr_Occurred()) SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CrossValidate, 0 |  0 );
  {
    if (is_new_object2 && array2)
    {
      Py_DECREF(array2); 
    }
  }
  {
    if (is_new_object4 && array4)
    {
      Py_DECREF(array4); 
    }
  }
  return resultobj;
fail:
  {
    if (is_new_object2 && array2)
    {
      Py_DECREF(array2); 
    }
  }
  {
    if (is_new_object4 && array4)
    {
      Py_DECREF(array4); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_aopts_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  PyArrayObject *array1 = NULL ;
  int is_new_object1 = 0 ;
  PyObject * obj0 = 0 ;
  struct LinElemExpAopts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_aopts_alloc",&obj0)) SWIG_fail;
  {
    npy_intp size[1] = {
      -1
    };
    array1 = obj_to_array_contiguous_allow_conversion(obj0,
      NPY_DOUBLE,
      &is_new_object1);
    if (!array1 || !require_dimensions(array1, 1) ||
      !require_size(array1, size, 1)) SWIG_fail;
    arg1 = (int) array_size(array1,0);
    arg2 = (double*) array_data(array1);
  }
  {
    result = (struct LinElemExpAopts *)my_lin_elem_exp_aopts_alloc(arg1,(double const *)arg2);
    if (PyErr_Occurred()) SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  {
    if (is_new_object1 && array1)
    {
      Py_DECREF(array1); 
    }
  }
  return resultobj;
fail:
  {
    if (is_new_object1 && array1)
    {
      Py_DECREF(array1); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyArrayObject *array2 = NULL ;
  int is_new_object2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_eval" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  {
    npy_intp size[1] = {
      -1
    };
    array2 = obj_to_array_contiguous_allow_conversion(obj1,
      NPY_DOUBLE,
      &is_new_object2);
    if (!array2 || !require_dimensions(array2, 1) ||
      !require_size(array2, size, 1)) SWIG_fail;
    arg2 = (int) array_size(array2,0);
    arg3 = (double*) array_data(array2);
  }
  {
    result = (double)my_function_train_eval(arg1,arg2,(double const *)arg3);
    if (PyErr_Occurred()) SWIG_fail;
  }
  resultobj = SWIG_From_double((double)(result));
  {
    if (is_new_object2 && array2)
    {
      Py_DECREF(array2); 
    }
  }
  return resultobj;
fail:
  {
    if (is_new_object2 && array2)
    {
      Py_DECREF(array2); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_gradient_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyArrayObject *array2 = NULL ;
  int is_new_object2 = 0 ;
  PyArrayObject *array4 = NULL ;
  int i4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:function_train_gradient_eval",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_gradient_eval" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  {
    npy_intp size[1] = {
      -1
    };
    array2 = obj_to_array_contiguous_allow_conversion(obj1,
      NPY_DOUBLE,
      &is_new_object2);
    if (!array2 || !require_dimensions(array2, 1) ||
      !require_size(array2, size, 1)) SWIG_fail;
    arg2 = (int) array_size(array2,0);
    arg3 = (double*) array_data(array2);
  }
  {
    array4 = obj_to_array_no_conversion(obj2, NPY_DOUBLE);
    if (!array4 || !require_dimensions(array4,1) || !require_contiguous(array4)
      || !require_native(array4)) SWIG_fail;
    arg4 = 1;
    for (i4=0; i4 < array_numdims(array4); ++i4) arg4 *= array_size(array4,i4);
    arg5 = (double*) array_data(array4);
  }
  {
    my_function_train_gradient_eval(arg1,arg2,(double const *)arg3,arg4,arg5);
    if (PyErr_Occurred()) SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  {
    if (is_new_object2 && array2)
    {
      Py_DECREF(array2); 
    }
  }
  return resultobj;
fail:
  {
    if (is_new_object2 && array2)
    {
      Py_DECREF(array2); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3approx_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum C3ATYPE arg1 ;
  size_t arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct C3Approx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3approx_create",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3approx_create" "', argument " "1"" of type '" "enum C3ATYPE""'");
  } 
  arg1 = (enum C3ATYPE)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3approx_create" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (struct C3Approx *)c3approx_create(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_C3Approx, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3approx_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3Approx *arg1 = (struct C3Approx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3approx_destroy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3Approx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3approx_destroy" "', argument " "1"" of type '" "struct C3Approx *""'"); 
  }
  arg1 = (struct C3Approx *)(argp1);
  c3approx_destroy(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3approx_set_approx_opts_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3Approx *arg1 = (struct C3Approx *) 0 ;
  size_t arg2 ;
  struct OneApproxOpts *arg3 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:c3approx_set_approx_opts_dim",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3Approx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3approx_set_approx_opts_dim" "', argument " "1"" of type '" "struct C3Approx *""'"); 
  }
  arg1 = (struct C3Approx *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3approx_set_approx_opts_dim" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3approx_set_approx_opts_dim" "', argument " "3"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg3 = (struct OneApproxOpts *)(argp3);
  c3approx_set_approx_opts_dim(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3approx_set_opt_opts_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3Approx *arg1 = (struct C3Approx *) 0 ;
  size_t arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:c3approx_set_opt_opts_dim",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3Approx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3approx_set_opt_opts_dim" "', argument " "1"" of type '" "struct C3Approx *""'"); 
  }
  arg1 = (struct C3Approx *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3approx_set_opt_opts_dim" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3approx_set_opt_opts_dim" "', argument " "3"" of type '" "void *""'"); 
  }
  c3approx_set_opt_opts_dim(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3approx_set_round_tol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3Approx *arg1 = (struct C3Approx *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3approx_set_round_tol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3Approx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3approx_set_round_tol" "', argument " "1"" of type '" "struct C3Approx *""'"); 
  }
  arg1 = (struct C3Approx *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3approx_set_round_tol" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  c3approx_set_round_tol(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3approx_set_verbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3Approx *arg1 = (struct C3Approx *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3approx_set_verbose",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3Approx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3approx_set_verbose" "', argument " "1"" of type '" "struct C3Approx *""'"); 
  }
  arg1 = (struct C3Approx *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3approx_set_verbose" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  c3approx_set_verbose(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3approx_init_cross(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3Approx *arg1 = (struct C3Approx *) 0 ;
  size_t arg2 ;
  int arg3 ;
  double **arg4 = (double **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:c3approx_init_cross",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3Approx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3approx_init_cross" "', argument " "1"" of type '" "struct C3Approx *""'"); 
  }
  arg1 = (struct C3Approx *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3approx_init_cross" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c3approx_init_cross" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "c3approx_init_cross" "', argument " "4"" of type '" "double **""'"); 
  }
  arg4 = (double **)(argp4);
  c3approx_init_cross(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3approx_set_cross_tol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3Approx *arg1 = (struct C3Approx *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3approx_set_cross_tol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3Approx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3approx_set_cross_tol" "', argument " "1"" of type '" "struct C3Approx *""'"); 
  }
  arg1 = (struct C3Approx *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3approx_set_cross_tol" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  c3approx_set_cross_tol(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3approx_set_adapt_kickrank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3Approx *arg1 = (struct C3Approx *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3approx_set_adapt_kickrank",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3Approx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3approx_set_adapt_kickrank" "', argument " "1"" of type '" "struct C3Approx *""'"); 
  }
  arg1 = (struct C3Approx *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3approx_set_adapt_kickrank" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  c3approx_set_adapt_kickrank(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3approx_set_adapt_maxrank_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3Approx *arg1 = (struct C3Approx *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3approx_set_adapt_maxrank_all",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3Approx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3approx_set_adapt_maxrank_all" "', argument " "1"" of type '" "struct C3Approx *""'"); 
  }
  arg1 = (struct C3Approx *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3approx_set_adapt_maxrank_all" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  c3approx_set_adapt_maxrank_all(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3approx_set_cross_maxiter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3Approx *arg1 = (struct C3Approx *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3approx_set_cross_maxiter",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3Approx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3approx_set_cross_maxiter" "', argument " "1"" of type '" "struct C3Approx *""'"); 
  }
  arg1 = (struct C3Approx *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3approx_set_cross_maxiter" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  c3approx_set_cross_maxiter(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3approx_do_cross(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3Approx *arg1 = (struct C3Approx *) 0 ;
  struct Fwrap *arg2 = (struct Fwrap *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:c3approx_do_cross",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3Approx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3approx_do_cross" "', argument " "1"" of type '" "struct C3Approx *""'"); 
  }
  arg1 = (struct C3Approx *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3approx_do_cross" "', argument " "2"" of type '" "struct Fwrap *""'"); 
  }
  arg2 = (struct Fwrap *)(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c3approx_do_cross" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  result = (struct FunctionTrain *)c3approx_do_cross(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3approx_get_approx_args(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3Approx *arg1 = (struct C3Approx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct MultiApproxOpts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3approx_get_approx_args",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3Approx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3approx_get_approx_args" "', argument " "1"" of type '" "struct C3Approx const *""'"); 
  }
  arg1 = (struct C3Approx *)(argp1);
  result = (struct MultiApproxOpts *)c3approx_get_approx_args((struct C3Approx const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3approx_get_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3Approx *arg1 = (struct C3Approx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3approx_get_dim",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3Approx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3approx_get_dim" "', argument " "1"" of type '" "struct C3Approx const *""'"); 
  }
  arg1 = (struct C3Approx *)(argp1);
  result = (size_t)c3approx_get_dim((struct C3Approx const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_calloc_double(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:calloc_double",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "calloc_double" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (double *)calloc_double(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_malloc_dd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  double **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:malloc_dd",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "malloc_dd" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (double **)malloc_dd(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_calloc_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:calloc_int",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "calloc_int" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (int *)calloc_int(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_calloc_size_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:calloc_size_t",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "calloc_size_t" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (size_t *)calloc_size_t(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_copy_dd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  double **arg3 = (double **) 0 ;
  double **arg4 = (double **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:copy_dd",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "copy_dd" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "copy_dd" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "copy_dd" "', argument " "3"" of type '" "double **""'"); 
  }
  arg3 = (double **)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "copy_dd" "', argument " "4"" of type '" "double **""'"); 
  }
  arg4 = (double **)(argp4);
  copy_dd(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_free_dd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double **arg2 = (double **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:free_dd",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "free_dd" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "free_dd" "', argument " "2"" of type '" "double **""'"); 
  }
  arg2 = (double **)(argp2);
  free_dd(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:dones",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dones" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (double *)dones(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_drandu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:drandu",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "drandu" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (double *)drandu(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_darray_val(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:darray_val",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "darray_val" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "darray_val" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double *)darray_val(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dzeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:dzeros",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dzeros" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (double *)dzeros(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_izeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:izeros",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "izeros" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (int *)izeros(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dprod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:dprod",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dprod" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dprod" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (double)dprod(arg1,(double const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_iprod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  int *arg2 = (int *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:iprod",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "iprod" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "iprod" "', argument " "2"" of type '" "int const *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (int)iprod(arg1,(int const *)arg2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_iprod_sz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t *arg2 = (size_t *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:iprod_sz",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "iprod_sz" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "iprod_sz" "', argument " "2"" of type '" "size_t const *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (size_t)iprod_sz(arg1,(unsigned long const *)arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dprint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:dprint",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dprint" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dprint" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  dprint(arg1,(double const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dprint2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:dprint2d",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dprint2d" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dprint2d" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dprint2d" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  dprint2d(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dprint2dd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  double **arg3 = (double **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:dprint2dd",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dprint2dd" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dprint2dd" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dprint2dd" "', argument " "3"" of type '" "double **""'"); 
  }
  arg3 = (double **)(argp3);
  dprint2dd(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dprint2d_col(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:dprint2d_col",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dprint2d_col" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dprint2d_col" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dprint2d_col" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  dprint2d_col(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_iprint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  int *arg2 = (int *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:iprint",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "iprint" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "iprint" "', argument " "2"" of type '" "int const *""'"); 
  }
  arg2 = (int *)(argp2);
  iprint(arg1,(int const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_iprint_sz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t *arg2 = (size_t *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:iprint_sz",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "iprint_sz" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "iprint_sz" "', argument " "2"" of type '" "size_t const *""'"); 
  }
  arg2 = (size_t *)(argp2);
  iprint_sz(arg1,(unsigned long const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_linspace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  size_t arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:linspace",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "linspace" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "linspace" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "linspace" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  result = (double *)linspace(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dd_row_linspace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double **arg1 = (double **) 0 ;
  size_t arg2 ;
  double arg3 ;
  double arg4 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:dd_row_linspace",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dd_row_linspace" "', argument " "1"" of type '" "double **""'"); 
  }
  arg1 = (double **)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dd_row_linspace" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dd_row_linspace" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dd_row_linspace" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dd_row_linspace" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  dd_row_linspace(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_logspace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  size_t arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:logspace",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "logspace" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "logspace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "logspace" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  result = (double *)logspace(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_arange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:arange",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "arange" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arange" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arange" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arange" "', argument " "4"" of type '" "size_t *""'"); 
  }
  arg4 = (size_t *)(argp4);
  result = (double *)arange(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_diag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:diag",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "diag" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "diag" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (double *)diag(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dconcat_cols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:dconcat_cols",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dconcat_cols" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dconcat_cols" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dconcat_cols" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dconcat_cols" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dconcat_cols" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  result = (double *)dconcat_cols(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_deserialize_double_from_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:deserialize_double_from_text",&obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deserialize_double_from_text" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  result = (double)deserialize_double_from_text(arg1);
  resultobj = SWIG_From_double((double)(result));
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_serialize_darray_to_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:serialize_darray_to_text",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "serialize_darray_to_text" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "serialize_darray_to_text" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (char *)serialize_darray_to_text(arg1,(double const *)arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_deserialize_darray_from_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:deserialize_darray_from_text",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deserialize_darray_from_text" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "deserialize_darray_from_text" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (double *)deserialize_darray_from_text(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_deserialize_double_packed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:deserialize_double_packed",&obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deserialize_double_packed" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  result = (double)deserialize_double_packed(arg1);
  resultobj = SWIG_From_double((double)(result));
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_serialize_double_arr_packed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:serialize_double_arr_packed",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "serialize_double_arr_packed" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "serialize_double_arr_packed" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (char *)serialize_double_arr_packed(arg1,(double const *)arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_darray_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:darray_save",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "darray_save" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "darray_save" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "darray_save" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "darray_save" "', argument " "4"" of type '" "char *""'");
  }
  arg4 = (char *)(buf4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "darray_save" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  result = (int)darray_save(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int((int)(result));
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return resultobj;
fail:
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return NULL;
}


SWIGINTERN PyObject *_wrap_darray_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:darray_load",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "darray_load" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "darray_load" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  result = (double *)darray_load(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3Vector_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Vector *arg1 = (struct c3Vector *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3Vector_size_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Vector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3Vector_size_set" "', argument " "1"" of type '" "struct c3Vector *""'"); 
  }
  arg1 = (struct c3Vector *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3Vector_size_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3Vector_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Vector *arg1 = (struct c3Vector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3Vector_size_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Vector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3Vector_size_get" "', argument " "1"" of type '" "struct c3Vector *""'"); 
  }
  arg1 = (struct c3Vector *)(argp1);
  result = (size_t) ((arg1)->size);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3Vector_elem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Vector *arg1 = (struct c3Vector *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3Vector_elem_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Vector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3Vector_elem_set" "', argument " "1"" of type '" "struct c3Vector *""'"); 
  }
  arg1 = (struct c3Vector *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3Vector_elem_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->elem = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3Vector_elem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Vector *arg1 = (struct c3Vector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3Vector_elem_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Vector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3Vector_elem_get" "', argument " "1"" of type '" "struct c3Vector *""'"); 
  }
  arg1 = (struct c3Vector *)(argp1);
  result = (double *) ((arg1)->elem);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_c3Vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Vector *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_c3Vector")) SWIG_fail;
  result = (struct c3Vector *)calloc(1, sizeof(struct c3Vector));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_c3Vector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_c3Vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Vector *arg1 = (struct c3Vector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_c3Vector",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Vector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_c3Vector" "', argument " "1"" of type '" "struct c3Vector *""'"); 
  }
  arg1 = (struct c3Vector *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_c3vector_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct c3Vector *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3vector_alloc",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3vector_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3vector_alloc" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (struct c3Vector *)c3vector_alloc(arg1,(double const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_c3Vector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3vector_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Vector *arg1 = (struct c3Vector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct c3Vector *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3vector_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Vector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3vector_copy" "', argument " "1"" of type '" "struct c3Vector const *""'"); 
  }
  arg1 = (struct c3Vector *)(argp1);
  result = (struct c3Vector *)c3vector_copy((struct c3Vector const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_c3Vector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3vector_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Vector *arg1 = (struct c3Vector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3vector_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Vector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3vector_free" "', argument " "1"" of type '" "struct c3Vector *""'"); 
  }
  arg1 = (struct c3Vector *)(argp1);
  c3vector_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3vector_array_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct c3Vector **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3vector_array_alloc",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3vector_array_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct c3Vector **)c3vector_array_alloc(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_c3Vector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3vector_array_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct c3Vector **arg2 = (struct c3Vector **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct c3Vector **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3vector_array_copy",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3vector_array_copy" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_c3Vector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3vector_array_copy" "', argument " "2"" of type '" "struct c3Vector **""'"); 
  }
  arg2 = (struct c3Vector **)(argp2);
  result = (struct c3Vector **)c3vector_array_copy(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_c3Vector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3vector_array_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct c3Vector **arg2 = (struct c3Vector **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3vector_array_free",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3vector_array_free" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_c3Vector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3vector_array_free" "', argument " "2"" of type '" "struct c3Vector **""'"); 
  }
  arg2 = (struct c3Vector **)(argp2);
  c3vector_array_free(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)":randu")) SWIG_fail;
  result = (double)randu();
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)":randn")) SWIG_fail;
  result = (double)randn();
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_strip_ends(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char arg2 ;
  char arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:strip_ends",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "strip_ends" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "strip_ends" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = (char)(val2);
  ecode3 = SWIG_AsVal_char(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "strip_ends" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = (char)(val3);
  strip_ends(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_strip_blank_ends(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:strip_blank_ends",&obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "strip_blank_ends" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  strip_blank_ends(arg1);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_bite_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:bite_string",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bite_string" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bite_string" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = (char)(val2);
  result = (char *)bite_string(arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_bite_string2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:bite_string2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bite_string2" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bite_string2" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  result = (char *)bite_string2(arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char arg2 ;
  size_t *arg3 = (size_t *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:parse_string",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_string" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "parse_string" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = (char)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "parse_string" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (char **)parse_string(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_concat_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:concat_string",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "concat_string" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "concat_string" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  result = (char *)concat_string(arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_concat_string_ow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char **arg1 = (char **) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:concat_string_ow",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "concat_string_ow" "', argument " "1"" of type '" "char **""'"); 
  }
  arg1 = (char **)(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "concat_string_ow" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  concat_string_ow(arg1,arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_itoa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:itoa",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "itoa" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "itoa" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "itoa" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  result = (char *)itoa(arg1,arg2,arg3);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_serialize_char(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:serialize_char",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "serialize_char" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "serialize_char" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = (char)(val2);
  result = (unsigned char *)serialize_char(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_serialize_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:serialize_int",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "serialize_int" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "serialize_int" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  result = (unsigned char *)serialize_int(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_deserialize_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:deserialize_int",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deserialize_int" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "deserialize_int" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (unsigned char *)deserialize_int(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_serialize_size_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:serialize_size_t",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "serialize_size_t" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "serialize_size_t" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (unsigned char *)serialize_size_t(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_deserialize_size_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:deserialize_size_t",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deserialize_size_t" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "deserialize_size_t" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (unsigned char *)deserialize_size_t(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_serialize_double(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:serialize_double",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "serialize_double" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "serialize_double" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (unsigned char *)serialize_double(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_deserialize_double(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:deserialize_double",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deserialize_double" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "deserialize_double" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (unsigned char *)deserialize_double(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_serialize_doublep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  double *arg2 = (double *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:serialize_doublep",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "serialize_doublep" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "serialize_doublep" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "serialize_doublep" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  result = (unsigned char *)serialize_doublep(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_deserialize_doublep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  double **arg2 = (double **) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:deserialize_doublep",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deserialize_doublep" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "deserialize_doublep" "', argument " "2"" of type '" "double **""'"); 
  }
  arg2 = (double **)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "deserialize_doublep" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (unsigned char *)deserialize_doublep(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_readtxt_double_array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:readtxt_double_array",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "readtxt_double_array" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "readtxt_double_array" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "readtxt_double_array" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (double *)readtxt_double_array(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_readfile_double_array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FILE *arg1 = (FILE *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:readfile_double_array",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "readfile_double_array" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = (FILE *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "readfile_double_array" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "readfile_double_array" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (double *)readfile_double_array(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct MultiApproxOpts *arg2 = (struct MultiApproxOpts *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct FTRegress *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ft_regress_alloc",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ft_regress_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_regress_alloc" "', argument " "2"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg2 = (struct MultiApproxOpts *)(argp2);
  {
    if (!PyList_Check(obj2)) {
      PyErr_SetString(PyExc_ValueError,"Expecting a list");
      return NULL;
    }
    int size = PyList_Size(obj2);
    arg3 = (size_t *) malloc(size * sizeof(size_t));
    for (int i = 0; i < size; i++){
      PyObject *s = PyList_GetItem(obj2,i);
      if (!PyInt_Check(s)) {
        free(arg3);
        PyErr_SetString(PyExc_ValueError, "List items must be integers");
        return NULL;
      }
      arg3[i] = PyInt_AsLong(s);
    }
  }
  result = (struct FTRegress *)ft_regress_alloc(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTRegress, 0 |  0 );
  {
    if (arg3) free(arg3);
  }
  return resultobj;
fail:
  {
    if (arg3) free(arg3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_sample_weights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_sample_weights",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_sample_weights" "', argument " "1"" of type '" "struct FTRegress const *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_regress_set_sample_weights" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  ft_regress_set_sample_weights((struct FTRegress const *)arg1,(double const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_get_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft_regress_get_dim",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_get_dim" "', argument " "1"" of type '" "struct FTRegress const *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  result = (size_t)ft_regress_get_dim((struct FTRegress const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_adapt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_adapt",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_adapt" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_adapt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ft_regress_set_adapt(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_maxrank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_maxrank",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_maxrank" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_maxrank" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ft_regress_set_maxrank(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_kickrank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_kickrank",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_kickrank" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_kickrank" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ft_regress_set_kickrank(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_roundtol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_roundtol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_roundtol" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_roundtol" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ft_regress_set_roundtol(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_kfold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_kfold",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_kfold" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_kfold" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ft_regress_set_kfold(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_finalize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_finalize" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_finalize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ft_regress_set_finalize(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_opt_restrict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_opt_restrict",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_opt_restrict" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_opt_restrict" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ft_regress_set_opt_restrict(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_kristoffel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_kristoffel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_kristoffel" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_kristoffel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ft_regress_set_kristoffel(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft_regress_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_free" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ft_regress_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_reset_param(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  struct MultiApproxOpts *arg2 = (struct MultiApproxOpts *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ft_regress_reset_param",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_reset_param" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_regress_reset_param" "', argument " "2"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg2 = (struct MultiApproxOpts *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ft_regress_reset_param" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  ft_regress_reset_param(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  enum REGTYPE arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_type",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_type" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_type" "', argument " "2"" of type '" "enum REGTYPE""'");
  } 
  arg2 = (enum REGTYPE)(val2);
  ft_regress_set_type(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_obj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  enum REGOBJ arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_obj",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_obj" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_obj" "', argument " "2"" of type '" "enum REGOBJ""'");
  } 
  arg2 = (enum REGOBJ)(val2);
  ft_regress_set_obj(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_alg_and_obj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  enum REGTYPE arg2 ;
  enum REGOBJ arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ft_regress_set_alg_and_obj",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_alg_and_obj" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_alg_and_obj" "', argument " "2"" of type '" "enum REGTYPE""'");
  } 
  arg2 = (enum REGTYPE)(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ft_regress_set_alg_and_obj" "', argument " "3"" of type '" "enum REGOBJ""'");
  } 
  arg3 = (enum REGOBJ)(val3);
  ft_regress_set_alg_and_obj(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_als_conv_tol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_als_conv_tol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_als_conv_tol" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_als_conv_tol" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ft_regress_set_als_conv_tol(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_max_als_sweep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_max_als_sweep",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_max_als_sweep" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_max_als_sweep" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ft_regress_set_max_als_sweep(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_verbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_verbose",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_verbose" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_verbose" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ft_regress_set_verbose(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_set_regularization_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_set_regularization_weight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_set_regularization_weight" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_set_regularization_weight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ft_regress_set_regularization_weight(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_get_regularization_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft_regress_get_regularization_weight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_get_regularization_weight" "', argument " "1"" of type '" "struct FTRegress const *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  result = (double)ft_regress_get_regularization_weight((struct FTRegress const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_get_nepochs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft_regress_get_nepochs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_get_nepochs" "', argument " "1"" of type '" "struct FTRegress const *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  result = (size_t)ft_regress_get_nepochs((struct FTRegress const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_get_stored_fvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_get_stored_fvals",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_get_stored_fvals" "', argument " "1"" of type '" "struct FTRegress const *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_get_stored_fvals" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double)ft_regress_get_stored_fvals((struct FTRegress const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_get_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_get_params",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_get_params" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_regress_get_params" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (double *)ft_regress_get_params(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_update_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_regress_update_params",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_update_params" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_regress_update_params" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  ft_regress_update_params(arg1,(double const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_regress_run_rankadapt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTRegress *arg1 = (struct FTRegress *) 0 ;
  double arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  struct c3Opt *arg5 = (struct c3Opt *) 0 ;
  int arg6 ;
  size_t arg7 ;
  double *arg8 = (double *) 0 ;
  double *arg9 = (double *) 0 ;
  int arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:ft_regress_run_rankadapt",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_regress_run_rankadapt" "', argument " "1"" of type '" "struct FTRegress *""'"); 
  }
  arg1 = (struct FTRegress *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_regress_run_rankadapt" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ft_regress_run_rankadapt" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ft_regress_run_rankadapt" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ft_regress_run_rankadapt" "', argument " "5"" of type '" "struct c3Opt *""'"); 
  }
  arg5 = (struct c3Opt *)(argp5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ft_regress_run_rankadapt" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  ecode7 = SWIG_AsVal_size_t(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ft_regress_run_rankadapt" "', argument " "7"" of type '" "size_t""'");
  } 
  arg7 = (size_t)(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ft_regress_run_rankadapt" "', argument " "8"" of type '" "double const *""'"); 
  }
  arg8 = (double *)(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ft_regress_run_rankadapt" "', argument " "9"" of type '" "double const *""'"); 
  }
  arg9 = (double *)(argp9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ft_regress_run_rankadapt" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = (int)(val10);
  result = (struct FunctionTrain *)ft_regress_run_rankadapt(arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,(double const *)arg9,arg10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_validate_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossValidate *arg1 = (struct CrossValidate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:cross_validate_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossValidate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cross_validate_free" "', argument " "1"" of type '" "struct CrossValidate *""'"); 
  }
  arg1 = (struct CrossValidate *)(argp1);
  cross_validate_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_validate_run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossValidate *arg1 = (struct CrossValidate *) 0 ;
  struct FTRegress *arg2 = (struct FTRegress *) 0 ;
  struct c3Opt *arg3 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:cross_validate_run",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossValidate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cross_validate_run" "', argument " "1"" of type '" "struct CrossValidate *""'"); 
  }
  arg1 = (struct CrossValidate *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cross_validate_run" "', argument " "2"" of type '" "struct FTRegress *""'"); 
  }
  arg2 = (struct FTRegress *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cross_validate_run" "', argument " "3"" of type '" "struct c3Opt *""'"); 
  }
  arg3 = (struct c3Opt *)(argp3);
  result = (double)cross_validate_run(arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cv_opt_grid_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct CVOptGrid *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:cv_opt_grid_init",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cv_opt_grid_init" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct CVOptGrid *)cv_opt_grid_init(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CVOptGrid, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cv_opt_grid_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CVOptGrid *arg1 = (struct CVOptGrid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:cv_opt_grid_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CVOptGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cv_opt_grid_free" "', argument " "1"" of type '" "struct CVOptGrid *""'"); 
  }
  arg1 = (struct CVOptGrid *)(argp1);
  cv_opt_grid_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cv_opt_grid_set_verbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CVOptGrid *arg1 = (struct CVOptGrid *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:cv_opt_grid_set_verbose",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CVOptGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cv_opt_grid_set_verbose" "', argument " "1"" of type '" "struct CVOptGrid *""'"); 
  }
  arg1 = (struct CVOptGrid *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cv_opt_grid_set_verbose" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  cv_opt_grid_set_verbose(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cv_opt_grid_add_param(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CVOptGrid *arg1 = (struct CVOptGrid *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:cv_opt_grid_add_param",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CVOptGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cv_opt_grid_add_param" "', argument " "1"" of type '" "struct CVOptGrid *""'"); 
  }
  arg1 = (struct CVOptGrid *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cv_opt_grid_add_param" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cv_opt_grid_add_param" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  {
    if (!PyList_Check(obj3)) {
      PyErr_SetString(PyExc_ValueError,"Expecting a list");
      return NULL;
    }
    int size = PyList_Size(obj3);
    
    PyObject *s = PyList_GetItem(obj3,0);
    int is_size_t = 0;
    if (PyInt_Check(s)){
      is_size_t = 1;
    }
    else{
      if (!PyFloat_Check(s)){
        PyErr_SetString(PyExc_ValueError, "List items must be integers or floats");
        return NULL;
      }
    }
    
    if (is_size_t == 1){
      arg4 = malloc(size * sizeof(size_t));
    }
    else{
      arg4 = malloc(size * sizeof(double));
    }
    for (int i = 0; i < size; i++){
      PyObject *s = PyList_GetItem(obj3,i);
      if (is_size_t == 1){
        if (!PyInt_Check(s)) {
          free(arg4);
          PyErr_SetString(PyExc_ValueError, "List items must the same type");
          return NULL;
        }
        ((size_t *)arg4)[i] = PyInt_AsLong(s);
      }
      else{
        if (!PyFloat_Check(s)) {
          free(arg4);
          PyErr_SetString(PyExc_ValueError, "List items must be the same type");
          return NULL;
        }
        ((double *)arg4)[i] = PyFloat_AsDouble(s);
      }
      
    }
  }
  cv_opt_grid_add_param(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  {
    if (arg4) free(arg4);
  }
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  {
    if (arg4) free(arg4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_validate_grid_opt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossValidate *arg1 = (struct CrossValidate *) 0 ;
  struct CVOptGrid *arg2 = (struct CVOptGrid *) 0 ;
  struct FTRegress *arg3 = (struct FTRegress *) 0 ;
  struct c3Opt *arg4 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:cross_validate_grid_opt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossValidate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cross_validate_grid_opt" "', argument " "1"" of type '" "struct CrossValidate *""'"); 
  }
  arg1 = (struct CrossValidate *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CVOptGrid, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cross_validate_grid_opt" "', argument " "2"" of type '" "struct CVOptGrid *""'"); 
  }
  arg2 = (struct CVOptGrid *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FTRegress, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cross_validate_grid_opt" "', argument " "3"" of type '" "struct FTRegress *""'"); 
  }
  arg3 = (struct FTRegress *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cross_validate_grid_opt" "', argument " "4"" of type '" "struct c3Opt *""'"); 
  }
  arg4 = (struct c3Opt *)(argp4);
  cross_validate_grid_opt(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3_regression_run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  struct RegressOpts *arg2 = (struct RegressOpts *) 0 ;
  struct c3Opt *arg3 = (struct c3Opt *) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:c3_regression_run",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3_regression_run" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3_regression_run" "', argument " "2"" of type '" "struct RegressOpts *""'"); 
  }
  arg2 = (struct RegressOpts *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3_regression_run" "', argument " "3"" of type '" "struct c3Opt *""'"); 
  }
  arg3 = (struct c3Opt *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "c3_regression_run" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "c3_regression_run" "', argument " "5"" of type '" "double const *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "c3_regression_run" "', argument " "6"" of type '" "double const *""'"); 
  }
  arg6 = (double *)(argp6);
  result = (struct FunctionTrain *)c3_regression_run(arg1,arg2,arg3,arg4,(double const *)arg5,(double const *)arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  enum REGTYPE arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RegressOpts_type_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_type_set" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RegressOpts_type_set" "', argument " "2"" of type '" "enum REGTYPE""'");
  } 
  arg2 = (enum REGTYPE)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum REGTYPE result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RegressOpts_type_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_type_get" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (enum REGTYPE) ((arg1)->type);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_obj_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  enum REGOBJ arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RegressOpts_obj_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_obj_set" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RegressOpts_obj_set" "', argument " "2"" of type '" "enum REGOBJ""'");
  } 
  arg2 = (enum REGOBJ)(val2);
  if (arg1) (arg1)->obj = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_obj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum REGOBJ result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RegressOpts_obj_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_obj_get" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (enum REGOBJ) ((arg1)->obj);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_dim_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RegressOpts_dim_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_dim_set" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RegressOpts_dim_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->dim = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_dim_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RegressOpts_dim_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_dim_get" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (size_t) ((arg1)->dim);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_verbose_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RegressOpts_verbose_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_verbose_set" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RegressOpts_verbose_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->verbose = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_verbose_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RegressOpts_verbose_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_verbose_get" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (int) ((arg1)->verbose);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_regularization_weight_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RegressOpts_regularization_weight_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_regularization_weight_set" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RegressOpts_regularization_weight_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->regularization_weight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_regularization_weight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RegressOpts_regularization_weight_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_regularization_weight_get" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (double) ((arg1)->regularization_weight);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_max_als_sweeps_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RegressOpts_max_als_sweeps_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_max_als_sweeps_set" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RegressOpts_max_als_sweeps_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->max_als_sweeps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_max_als_sweeps_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RegressOpts_max_als_sweeps_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_max_als_sweeps_get" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (size_t) ((arg1)->max_als_sweeps);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_als_active_core_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RegressOpts_als_active_core_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_als_active_core_set" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RegressOpts_als_active_core_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->als_active_core = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_als_active_core_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RegressOpts_als_active_core_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_als_active_core_get" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (size_t) ((arg1)->als_active_core);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_als_conv_tol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RegressOpts_als_conv_tol_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_als_conv_tol_set" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RegressOpts_als_conv_tol_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->als_conv_tol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_als_conv_tol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RegressOpts_als_conv_tol_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_als_conv_tol_get" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (double) ((arg1)->als_conv_tol);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_restrict_rank_opt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RegressOpts_restrict_rank_opt_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_restrict_rank_opt_set" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RegressOpts_restrict_rank_opt_set" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  if (arg1) (arg1)->restrict_rank_opt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_restrict_rank_opt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RegressOpts_restrict_rank_opt_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_restrict_rank_opt_get" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (size_t *) ((arg1)->restrict_rank_opt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_kristoffel_active_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RegressOpts_kristoffel_active_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_kristoffel_active_set" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RegressOpts_kristoffel_active_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->kristoffel_active = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_kristoffel_active_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RegressOpts_kristoffel_active_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_kristoffel_active_get" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (int) ((arg1)->kristoffel_active);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_nepochs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RegressOpts_nepochs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_nepochs_set" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RegressOpts_nepochs_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->nepochs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_nepochs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RegressOpts_nepochs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_nepochs_get" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (size_t) ((arg1)->nepochs);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_stored_fvals_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RegressOpts_stored_fvals_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_stored_fvals_set" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RegressOpts_stored_fvals_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->stored_fvals = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_stored_fvals_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RegressOpts_stored_fvals_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_stored_fvals_get" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (double *) ((arg1)->stored_fvals);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_sample_weights_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RegressOpts_sample_weights_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_sample_weights_set" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RegressOpts_sample_weights_set" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->sample_weights = (double const *)arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RegressOpts_sample_weights_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RegressOpts_sample_weights_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegressOpts_sample_weights_get" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (double *) ((arg1)->sample_weights);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegressOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RegressOpts")) SWIG_fail;
  result = (struct RegressOpts *)calloc(1, sizeof(struct RegressOpts));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RegressOpts, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RegressOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RegressOpts",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegressOpts" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_regress_opts_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct RegressOpts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:regress_opts_alloc",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "regress_opts_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct RegressOpts *)regress_opts_alloc(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RegressOpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_opts_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:regress_opts_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_opts_free" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  regress_opts_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_opts_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  enum REGTYPE arg2 ;
  enum REGOBJ arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct RegressOpts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:regress_opts_create",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "regress_opts_create" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "regress_opts_create" "', argument " "2"" of type '" "enum REGTYPE""'");
  } 
  arg2 = (enum REGTYPE)(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "regress_opts_create" "', argument " "3"" of type '" "enum REGOBJ""'");
  } 
  arg3 = (enum REGOBJ)(val3);
  result = (struct RegressOpts *)regress_opts_create(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RegressOpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_opts_set_sample_weights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:regress_opts_set_sample_weights",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_opts_set_sample_weights" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "regress_opts_set_sample_weights" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  regress_opts_set_sample_weights(arg1,(double const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_opts_set_max_als_sweep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:regress_opts_set_max_als_sweep",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_opts_set_max_als_sweep" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "regress_opts_set_max_als_sweep" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  regress_opts_set_max_als_sweep(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_opts_set_kristoffel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:regress_opts_set_kristoffel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_opts_set_kristoffel" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "regress_opts_set_kristoffel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  regress_opts_set_kristoffel(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_opts_set_als_conv_tol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:regress_opts_set_als_conv_tol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_opts_set_als_conv_tol" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "regress_opts_set_als_conv_tol" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  regress_opts_set_als_conv_tol(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_opts_set_verbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:regress_opts_set_verbose",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_opts_set_verbose" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "regress_opts_set_verbose" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  regress_opts_set_verbose(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_opts_set_restrict_rank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:regress_opts_set_restrict_rank",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_opts_set_restrict_rank" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "regress_opts_set_restrict_rank" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "regress_opts_set_restrict_rank" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  regress_opts_set_restrict_rank(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_opts_set_regularization_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:regress_opts_set_regularization_weight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_opts_set_regularization_weight" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "regress_opts_set_regularization_weight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  regress_opts_set_regularization_weight(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_opts_get_regularization_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:regress_opts_get_regularization_weight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_opts_get_regularization_weight" "', argument " "1"" of type '" "struct RegressOpts const *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (double)regress_opts_get_regularization_weight((struct RegressOpts const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_opts_add_stored_vals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:regress_opts_add_stored_vals",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_opts_add_stored_vals" "', argument " "1"" of type '" "struct RegressOpts *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "regress_opts_add_stored_vals" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "regress_opts_add_stored_vals" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  regress_opts_add_stored_vals(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_opts_get_nepochs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:regress_opts_get_nepochs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_opts_get_nepochs" "', argument " "1"" of type '" "struct RegressOpts const *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (size_t)regress_opts_get_nepochs((struct RegressOpts const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_opts_get_stored_fvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct RegressOpts *arg1 = (struct RegressOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:regress_opts_get_stored_fvals",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RegressOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_opts_get_stored_fvals" "', argument " "1"" of type '" "struct RegressOpts const *""'"); 
  }
  arg1 = (struct RegressOpts *)(argp1);
  result = (double *)regress_opts_get_stored_fvals((struct RegressOpts const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_objective_function_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ObjectiveFunction **arg1 = (struct ObjectiveFunction **) 0 ;
  double arg2 ;
  double (*arg3)(size_t,double const *,double *,size_t,size_t *,struct Data *,struct SLMemManager *,void *) = (double (*)(size_t,double const *,double *,size_t,size_t *,struct Data *,struct SLMemManager *,void *)) 0 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:objective_function_add",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_ObjectiveFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objective_function_add" "', argument " "1"" of type '" "struct ObjectiveFunction **""'"); 
  }
  arg1 = (struct ObjectiveFunction **)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "objective_function_add" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_unsigned_long_p_q_const__double_p_double_unsigned_long_p_unsigned_long_p_struct_Data_p_struct_SLMemManager_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "objective_function_add" "', argument " "3"" of type '" "double (*)(size_t,double const *,double *,size_t,size_t *,struct Data *,struct SLMemManager *,void *)""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "objective_function_add" "', argument " "4"" of type '" "void *""'"); 
  }
  objective_function_add(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_objective_function_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ObjectiveFunction **arg1 = (struct ObjectiveFunction **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:objective_function_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_ObjectiveFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objective_function_free" "', argument " "1"" of type '" "struct ObjectiveFunction **""'"); 
  }
  arg1 = (struct ObjectiveFunction **)(argp1);
  objective_function_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_objective_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  size_t *arg5 = (size_t *) 0 ;
  void *arg6 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:objective_eval",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "objective_eval" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objective_eval" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "objective_eval" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "objective_eval" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "objective_eval" "', argument " "5"" of type '" "size_t *""'"); 
  }
  arg5 = (size_t *)(argp5);
  res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "objective_eval" "', argument " "6"" of type '" "void *""'"); 
  }
  result = (double)objective_eval(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LeastSquaresArgs_mapping_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LeastSquaresArgs *arg1 = (struct LeastSquaresArgs *) 0 ;
  int (*arg2)(size_t,double const *,size_t,size_t *,struct SLMemManager *,struct Data *,double **,double **,void *) = (int (*)(size_t,double const *,size_t,size_t *,struct SLMemManager *,struct Data *,double **,double **,void *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LeastSquaresArgs_mapping_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LeastSquaresArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeastSquaresArgs_mapping_set" "', argument " "1"" of type '" "struct LeastSquaresArgs *""'"); 
  }
  arg1 = (struct LeastSquaresArgs *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_unsigned_long_p_q_const__double_unsigned_long_p_unsigned_long_p_struct_SLMemManager_p_struct_Data_p_p_double_p_p_double_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "LeastSquaresArgs_mapping_set" "', argument " "2"" of type '" "int (*)(size_t,double const *,size_t,size_t *,struct SLMemManager *,struct Data *,double **,double **,void *)""'"); 
    }
  }
  if (arg1) (arg1)->mapping = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LeastSquaresArgs_mapping_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LeastSquaresArgs *arg1 = (struct LeastSquaresArgs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int (*result)(size_t,double const *,size_t,size_t *,struct SLMemManager *,struct Data *,double **,double **,void *) = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LeastSquaresArgs_mapping_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LeastSquaresArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeastSquaresArgs_mapping_get" "', argument " "1"" of type '" "struct LeastSquaresArgs *""'"); 
  }
  arg1 = (struct LeastSquaresArgs *)(argp1);
  result = (int (*)(size_t,double const *,size_t,size_t *,struct SLMemManager *,struct Data *,double **,double **,void *)) ((arg1)->mapping);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_unsigned_long_p_q_const__double_unsigned_long_p_unsigned_long_p_struct_SLMemManager_p_struct_Data_p_p_double_p_p_double_p_void__int);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LeastSquaresArgs_args_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LeastSquaresArgs *arg1 = (struct LeastSquaresArgs *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LeastSquaresArgs_args_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LeastSquaresArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeastSquaresArgs_args_set" "', argument " "1"" of type '" "struct LeastSquaresArgs *""'"); 
  }
  arg1 = (struct LeastSquaresArgs *)(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LeastSquaresArgs_args_set" "', argument " "2"" of type '" "void *""'"); 
  }
  if (arg1) (arg1)->args = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LeastSquaresArgs_args_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LeastSquaresArgs *arg1 = (struct LeastSquaresArgs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LeastSquaresArgs_args_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LeastSquaresArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeastSquaresArgs_args_get" "', argument " "1"" of type '" "struct LeastSquaresArgs *""'"); 
  }
  arg1 = (struct LeastSquaresArgs *)(argp1);
  result = (void *) ((arg1)->args);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LeastSquaresArgs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LeastSquaresArgs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LeastSquaresArgs")) SWIG_fail;
  result = (struct LeastSquaresArgs *)calloc(1, sizeof(struct LeastSquaresArgs));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LeastSquaresArgs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LeastSquaresArgs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LeastSquaresArgs *arg1 = (struct LeastSquaresArgs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LeastSquaresArgs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LeastSquaresArgs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LeastSquaresArgs" "', argument " "1"" of type '" "struct LeastSquaresArgs *""'"); 
  }
  arg1 = (struct LeastSquaresArgs *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_c3_objective_function_least_squares(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  size_t *arg5 = (size_t *) 0 ;
  struct Data *arg6 = (struct Data *) 0 ;
  struct SLMemManager *arg7 = (struct SLMemManager *) 0 ;
  void *arg8 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int res8 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:c3_objective_function_least_squares",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3_objective_function_least_squares" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3_objective_function_least_squares" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3_objective_function_least_squares" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "c3_objective_function_least_squares" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "c3_objective_function_least_squares" "', argument " "5"" of type '" "size_t *""'"); 
  }
  arg5 = (size_t *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Data, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "c3_objective_function_least_squares" "', argument " "6"" of type '" "struct Data *""'"); 
  }
  arg6 = (struct Data *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_SLMemManager, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "c3_objective_function_least_squares" "', argument " "7"" of type '" "struct SLMemManager *""'"); 
  }
  arg7 = (struct SLMemManager *)(argp7);
  res8 = SWIG_ConvertPtr(obj7,SWIG_as_voidptrptr(&arg8), 0, 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "c3_objective_function_least_squares" "', argument " "8"" of type '" "void *""'"); 
  }
  result = (double)c3_objective_function_least_squares(arg1,(double const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_ft_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FTparam_ft_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_ft_set" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FTparam_ft_set" "', argument " "2"" of type '" "struct FunctionTrain *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  if (arg1) (arg1)->ft = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_ft_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FTparam_ft_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_ft_get" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  result = (struct FunctionTrain *) ((arg1)->ft);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_dim_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FTparam_dim_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_dim_set" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FTparam_dim_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->dim = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_dim_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FTparam_dim_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_dim_get" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  result = (size_t) ((arg1)->dim);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_nparams_per_uni_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FTparam_nparams_per_uni_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_nparams_per_uni_set" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FTparam_nparams_per_uni_set" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  if (arg1) (arg1)->nparams_per_uni = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_nparams_per_uni_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FTparam_nparams_per_uni_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_nparams_per_uni_get" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  result = (size_t *) ((arg1)->nparams_per_uni);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_nparams_per_core_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FTparam_nparams_per_core_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_nparams_per_core_set" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FTparam_nparams_per_core_set" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  if (arg1) (arg1)->nparams_per_core = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_nparams_per_core_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FTparam_nparams_per_core_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_nparams_per_core_get" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  result = (size_t *) ((arg1)->nparams_per_core);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_max_param_uni_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FTparam_max_param_uni_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_max_param_uni_set" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FTparam_max_param_uni_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->max_param_uni = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_max_param_uni_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FTparam_max_param_uni_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_max_param_uni_get" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  result = (size_t) ((arg1)->max_param_uni);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_nparams_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FTparam_nparams_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_nparams_set" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FTparam_nparams_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->nparams = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_nparams_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FTparam_nparams_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_nparams_get" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  result = (size_t) ((arg1)->nparams);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_params_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FTparam_params_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_params_set" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FTparam_params_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_params_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FTparam_params_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_params_get" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  result = (double *) ((arg1)->params);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_approx_opts_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  struct MultiApproxOpts *arg2 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FTparam_approx_opts_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_approx_opts_set" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_MultiApproxOpts, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FTparam_approx_opts_set" "', argument " "2"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg2 = (struct MultiApproxOpts *)(argp2);
  if (arg1) (arg1)->approx_opts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FTparam_approx_opts_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct MultiApproxOpts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FTparam_approx_opts_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FTparam_approx_opts_get" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  result = (struct MultiApproxOpts *) ((arg1)->approx_opts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FTparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FTparam")) SWIG_fail;
  result = (struct FTparam *)calloc(1, sizeof(struct FTparam));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTparam, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FTparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FTparam",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FTparam" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_ft_param_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct MultiApproxOpts *arg2 = (struct MultiApproxOpts *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t *arg4 = (size_t *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct FTparam *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ft_param_alloc",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ft_param_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_param_alloc" "', argument " "2"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg2 = (struct MultiApproxOpts *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ft_param_alloc" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ft_param_alloc" "', argument " "4"" of type '" "size_t *""'"); 
  }
  arg4 = (size_t *)(argp4);
  result = (struct FTparam *)ft_param_alloc(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTparam, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft_param_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_free" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ft_param_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_get_param(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_param_get_param",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_get_param" "', argument " "1"" of type '" "struct FTparam const *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_param_get_param" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double)ft_param_get_param((struct FTparam const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_get_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft_param_get_nparams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_get_nparams" "', argument " "1"" of type '" "struct FTparam const *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  result = (size_t)ft_param_get_nparams((struct FTparam const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_get_nparams_restrict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_param_get_nparams_restrict",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_get_nparams_restrict" "', argument " "1"" of type '" "struct FTparam const *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_param_get_nparams_restrict" "', argument " "2"" of type '" "size_t const *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (size_t)ft_param_get_nparams_restrict((struct FTparam const *)arg1,(unsigned long const *)arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_get_nparams_per_core(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft_param_get_nparams_per_core",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_get_nparams_per_core" "', argument " "1"" of type '" "struct FTparam const *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  result = (size_t *)ft_param_get_nparams_per_core((struct FTparam const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_get_ft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft_param_get_ft",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_get_ft" "', argument " "1"" of type '" "struct FTparam const *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  result = (struct FunctionTrain *)ft_param_get_ft((struct FTparam const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_create_constant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ft_param_create_constant",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_create_constant" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_param_create_constant" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ft_param_create_constant" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ft_param_create_constant(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_create_from_lin_ls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ft_param_create_from_lin_ls",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_create_from_lin_ls" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_param_create_from_lin_ls" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ft_param_create_from_lin_ls" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ft_param_create_from_lin_ls" "', argument " "4"" of type '" "double const *""'"); 
  }
  arg4 = (double *)(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ft_param_create_from_lin_ls" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  ft_param_create_from_lin_ls(arg1,arg2,(double const *)arg3,(double const *)arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_update_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_param_update_params",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_update_params" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_param_update_params" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  ft_param_update_params(arg1,(double const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_update_restricted_ranks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  double *arg2 = (double *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ft_param_update_restricted_ranks",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_update_restricted_ranks" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_param_update_restricted_ranks" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ft_param_update_restricted_ranks" "', argument " "3"" of type '" "size_t const *""'"); 
  }
  arg3 = (size_t *)(argp3);
  ft_param_update_restricted_ranks(arg1,(double const *)arg2,(unsigned long const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_update_inside_restricted_ranks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  double *arg2 = (double *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ft_param_update_inside_restricted_ranks",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_update_inside_restricted_ranks" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_param_update_inside_restricted_ranks" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ft_param_update_inside_restricted_ranks" "', argument " "3"" of type '" "size_t const *""'"); 
  }
  arg3 = (size_t *)(argp3);
  ft_param_update_inside_restricted_ranks(arg1,(double const *)arg2,(unsigned long const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_update_core_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ft_param_update_core_params",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_update_core_params" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_param_update_core_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ft_param_update_core_params" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  ft_param_update_core_params(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_extract_structure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum FTPARAM_ST result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft_param_extract_structure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_extract_structure" "', argument " "1"" of type '" "struct FTparam const *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  result = (enum FTPARAM_ST)ft_param_extract_structure((struct FTparam const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_gradeval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ft_param_gradeval",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_gradeval" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_param_gradeval" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ft_param_gradeval" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ft_param_gradeval" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ft_param_gradeval" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ft_param_gradeval" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  result = (double)ft_param_gradeval(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_eval_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ft_param_eval_lin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_eval_lin" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_param_eval_lin" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ft_param_eval_lin" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (double)ft_param_eval_lin(arg1,(double const *)arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_gradeval_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ft_param_gradeval_lin",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_gradeval_lin" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_param_gradeval_lin" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ft_param_gradeval_lin" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ft_param_gradeval_lin" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ft_param_gradeval_lin" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  result = (double)ft_param_gradeval_lin(arg1,(double const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_process_sweep_left_right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t arg2 ;
  double arg3 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:process_sweep_left_right",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "process_sweep_left_right" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "process_sweep_left_right" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "process_sweep_left_right" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "process_sweep_left_right" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "process_sweep_left_right" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "process_sweep_left_right" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  process_sweep_left_right(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_process_sweep_right_left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t arg2 ;
  double arg3 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:process_sweep_right_left",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "process_sweep_right_left" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "process_sweep_right_left" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "process_sweep_right_left" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "process_sweep_right_left" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "process_sweep_right_left" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "process_sweep_right_left" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  process_sweep_right_left(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_process_sweep_left_right_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:process_sweep_left_right_lin",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "process_sweep_left_right_lin" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "process_sweep_left_right_lin" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "process_sweep_left_right_lin" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "process_sweep_left_right_lin" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "process_sweep_left_right_lin" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  process_sweep_left_right_lin(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_process_sweep_right_left_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:process_sweep_right_left_lin",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "process_sweep_right_left_lin" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "process_sweep_right_left_lin" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "process_sweep_right_left_lin" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "process_sweep_right_left_lin" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "process_sweep_right_left_lin" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  process_sweep_right_left_lin(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_core_gradeval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t arg2 ;
  double arg3 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  double *arg7 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ft_param_core_gradeval",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_core_gradeval" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_param_core_gradeval" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ft_param_core_gradeval" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ft_param_core_gradeval" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ft_param_core_gradeval" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ft_param_core_gradeval" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ft_param_core_gradeval" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  result = (double)ft_param_core_gradeval(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_core_eval_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ft_param_core_eval_lin",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_core_eval_lin" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_param_core_eval_lin" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ft_param_core_eval_lin" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ft_param_core_eval_lin" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ft_param_core_eval_lin" "', argument " "5"" of type '" "double const *""'"); 
  }
  arg5 = (double *)(argp5);
  result = (double)ft_param_core_eval_lin(arg1,arg2,arg3,arg4,(double const *)arg5);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_core_gradeval_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ft_param_core_gradeval_lin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_core_gradeval_lin" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_param_core_gradeval_lin" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ft_param_core_gradeval_lin" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ft_param_core_gradeval_lin" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ft_param_core_gradeval_lin" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ft_param_core_gradeval_lin" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  result = (double)ft_param_core_gradeval_lin(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_param_hessvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FTparam *arg1 = (struct FTparam *) 0 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ft_param_hessvec",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FTparam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_param_hessvec" "', argument " "1"" of type '" "struct FTparam *""'"); 
  }
  arg1 = (struct FTparam *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft_param_hessvec" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ft_param_hessvec" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ft_param_hessvec" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (double)ft_param_hessvec(arg1,(double const *)arg2,(double const *)arg3,arg4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLP_objective_function_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  struct ObjectiveFunction *arg2 = (struct ObjectiveFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SLP_objective_function_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLP_objective_function_set" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ObjectiveFunction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLP_objective_function_set" "', argument " "2"" of type '" "struct ObjectiveFunction *""'"); 
  }
  arg2 = (struct ObjectiveFunction *)(argp2);
  if (arg1) (arg1)->objective_function = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLP_objective_function_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct ObjectiveFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SLP_objective_function_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLP_objective_function_get" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  result = (struct ObjectiveFunction *) ((arg1)->objective_function);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ObjectiveFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLP_optimizer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  struct c3Opt *arg2 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SLP_optimizer_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLP_optimizer_set" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_c3Opt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLP_optimizer_set" "', argument " "2"" of type '" "struct c3Opt *""'"); 
  }
  arg2 = (struct c3Opt *)(argp2);
  if (arg1) (arg1)->optimizer = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLP_optimizer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct c3Opt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SLP_optimizer_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLP_optimizer_get" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  result = (struct c3Opt *) ((arg1)->optimizer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_c3Opt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLP_data_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  struct Data *arg2 = (struct Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SLP_data_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLP_data_set" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Data, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLP_data_set" "', argument " "2"" of type '" "struct Data *""'"); 
  }
  arg2 = (struct Data *)(argp2);
  if (arg1) (arg1)->data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLP_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Data *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SLP_data_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLP_data_get" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  result = (struct Data *) ((arg1)->data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Data, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLP_mem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  struct SLMemManager *arg2 = (struct SLMemManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SLP_mem_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLP_mem_set" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SLMemManager, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLP_mem_set" "', argument " "2"" of type '" "struct SLMemManager *""'"); 
  }
  arg2 = (struct SLMemManager *)(argp2);
  if (arg1) (arg1)->mem = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLP_mem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct SLMemManager *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SLP_mem_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLP_mem_get" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  result = (struct SLMemManager *) ((arg1)->mem);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SLMemManager, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLP_nparams_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SLP_nparams_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLP_nparams_set" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SLP_nparams_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->nparams = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLP_nparams_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SLP_nparams_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLP_nparams_get" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  result = (size_t) ((arg1)->nparams);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLP_obj_min_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SLP_obj_min_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLP_obj_min_set" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SLP_obj_min_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->obj_min = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLP_obj_min_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SLP_obj_min_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLP_obj_min_get" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  result = (double) ((arg1)->obj_min);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SLP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SLP")) SWIG_fail;
  result = (struct SLP *)calloc(1, sizeof(struct SLP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SLP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SLP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SLP",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SLP" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_slp_solve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:slp_solve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "slp_solve" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "slp_solve" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (int)slp_solve(arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_slp_get_minimum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SLP *arg1 = (struct SLP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:slp_get_minimum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SLP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "slp_get_minimum" "', argument " "1"" of type '" "struct SLP *""'"); 
  }
  arg1 = (struct SLP *)(argp1);
  result = (double)slp_get_minimum(arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dmrg_diffusion_midleft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  struct Qmarray *arg3 = (struct Qmarray *) 0 ;
  struct Qmarray *arg4 = (struct Qmarray *) 0 ;
  struct Qmarray *arg5 = (struct Qmarray *) 0 ;
  double *arg6 = (double *) 0 ;
  size_t arg7 ;
  struct Qmarray *arg8 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:dmrg_diffusion_midleft",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dmrg_diffusion_midleft" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dmrg_diffusion_midleft" "', argument " "2"" of type '" "struct Qmarray *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dmrg_diffusion_midleft" "', argument " "3"" of type '" "struct Qmarray *""'"); 
  }
  arg3 = (struct Qmarray *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dmrg_diffusion_midleft" "', argument " "4"" of type '" "struct Qmarray *""'"); 
  }
  arg4 = (struct Qmarray *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dmrg_diffusion_midleft" "', argument " "5"" of type '" "struct Qmarray *""'"); 
  }
  arg5 = (struct Qmarray *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dmrg_diffusion_midleft" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  ecode7 = SWIG_AsVal_size_t(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "dmrg_diffusion_midleft" "', argument " "7"" of type '" "size_t""'");
  } 
  arg7 = (size_t)(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dmrg_diffusion_midleft" "', argument " "8"" of type '" "struct Qmarray *""'"); 
  }
  arg8 = (struct Qmarray *)(argp8);
  dmrg_diffusion_midleft(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dmrg_diffusion_lastleft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  struct Qmarray *arg3 = (struct Qmarray *) 0 ;
  struct Qmarray *arg4 = (struct Qmarray *) 0 ;
  struct Qmarray *arg5 = (struct Qmarray *) 0 ;
  double *arg6 = (double *) 0 ;
  size_t arg7 ;
  struct Qmarray *arg8 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:dmrg_diffusion_lastleft",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dmrg_diffusion_lastleft" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dmrg_diffusion_lastleft" "', argument " "2"" of type '" "struct Qmarray *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dmrg_diffusion_lastleft" "', argument " "3"" of type '" "struct Qmarray *""'"); 
  }
  arg3 = (struct Qmarray *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dmrg_diffusion_lastleft" "', argument " "4"" of type '" "struct Qmarray *""'"); 
  }
  arg4 = (struct Qmarray *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dmrg_diffusion_lastleft" "', argument " "5"" of type '" "struct Qmarray *""'"); 
  }
  arg5 = (struct Qmarray *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dmrg_diffusion_lastleft" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  ecode7 = SWIG_AsVal_size_t(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "dmrg_diffusion_lastleft" "', argument " "7"" of type '" "size_t""'");
  } 
  arg7 = (size_t)(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dmrg_diffusion_lastleft" "', argument " "8"" of type '" "struct Qmarray *""'"); 
  }
  arg8 = (struct Qmarray *)(argp8);
  dmrg_diffusion_lastleft(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dmrg_diffusion_midright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  struct Qmarray *arg3 = (struct Qmarray *) 0 ;
  struct Qmarray *arg4 = (struct Qmarray *) 0 ;
  struct Qmarray *arg5 = (struct Qmarray *) 0 ;
  double *arg6 = (double *) 0 ;
  size_t arg7 ;
  struct Qmarray *arg8 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:dmrg_diffusion_midright",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dmrg_diffusion_midright" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dmrg_diffusion_midright" "', argument " "2"" of type '" "struct Qmarray *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dmrg_diffusion_midright" "', argument " "3"" of type '" "struct Qmarray *""'"); 
  }
  arg3 = (struct Qmarray *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dmrg_diffusion_midright" "', argument " "4"" of type '" "struct Qmarray *""'"); 
  }
  arg4 = (struct Qmarray *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dmrg_diffusion_midright" "', argument " "5"" of type '" "struct Qmarray *""'"); 
  }
  arg5 = (struct Qmarray *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dmrg_diffusion_midright" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  ecode7 = SWIG_AsVal_size_t(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "dmrg_diffusion_midright" "', argument " "7"" of type '" "size_t""'");
  } 
  arg7 = (size_t)(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dmrg_diffusion_midright" "', argument " "8"" of type '" "struct Qmarray *""'"); 
  }
  arg8 = (struct Qmarray *)(argp8);
  dmrg_diffusion_midright(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dmrg_diffusion_firstright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  struct Qmarray *arg3 = (struct Qmarray *) 0 ;
  struct Qmarray *arg4 = (struct Qmarray *) 0 ;
  struct Qmarray *arg5 = (struct Qmarray *) 0 ;
  double *arg6 = (double *) 0 ;
  size_t arg7 ;
  struct Qmarray *arg8 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:dmrg_diffusion_firstright",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dmrg_diffusion_firstright" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dmrg_diffusion_firstright" "', argument " "2"" of type '" "struct Qmarray *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dmrg_diffusion_firstright" "', argument " "3"" of type '" "struct Qmarray *""'"); 
  }
  arg3 = (struct Qmarray *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dmrg_diffusion_firstright" "', argument " "4"" of type '" "struct Qmarray *""'"); 
  }
  arg4 = (struct Qmarray *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dmrg_diffusion_firstright" "', argument " "5"" of type '" "struct Qmarray *""'"); 
  }
  arg5 = (struct Qmarray *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dmrg_diffusion_firstright" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  ecode7 = SWIG_AsVal_size_t(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "dmrg_diffusion_firstright" "', argument " "7"" of type '" "size_t""'");
  } 
  arg7 = (size_t)(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dmrg_diffusion_firstright" "', argument " "8"" of type '" "struct Qmarray *""'"); 
  }
  arg8 = (struct Qmarray *)(argp8);
  dmrg_diffusion_firstright(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DmDiff_A_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmDiff *arg1 = (struct DmDiff *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DmDiff_A_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DmDiff_A_set" "', argument " "1"" of type '" "struct DmDiff *""'"); 
  }
  arg1 = (struct DmDiff *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DmDiff_A_set" "', argument " "2"" of type '" "struct FunctionTrain *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  if (arg1) (arg1)->A = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DmDiff_A_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmDiff *arg1 = (struct DmDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DmDiff_A_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DmDiff_A_get" "', argument " "1"" of type '" "struct DmDiff *""'"); 
  }
  arg1 = (struct DmDiff *)(argp1);
  result = (struct FunctionTrain *) ((arg1)->A);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DmDiff_F_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmDiff *arg1 = (struct DmDiff *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DmDiff_F_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DmDiff_F_set" "', argument " "1"" of type '" "struct DmDiff *""'"); 
  }
  arg1 = (struct DmDiff *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DmDiff_F_set" "', argument " "2"" of type '" "struct FunctionTrain *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  if (arg1) (arg1)->F = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DmDiff_F_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmDiff *arg1 = (struct DmDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DmDiff_F_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DmDiff_F_get" "', argument " "1"" of type '" "struct DmDiff *""'"); 
  }
  arg1 = (struct DmDiff *)(argp1);
  result = (struct FunctionTrain *) ((arg1)->F);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DmDiff_dA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmDiff *arg1 = (struct DmDiff *) 0 ;
  struct Qmarray **arg2 = (struct Qmarray **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DmDiff_dA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DmDiff_dA_set" "', argument " "1"" of type '" "struct DmDiff *""'"); 
  }
  arg1 = (struct DmDiff *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DmDiff_dA_set" "', argument " "2"" of type '" "struct Qmarray **""'"); 
  }
  arg2 = (struct Qmarray **)(argp2);
  if (arg1) (arg1)->dA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DmDiff_dA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmDiff *arg1 = (struct DmDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Qmarray **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DmDiff_dA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DmDiff_dA_get" "', argument " "1"" of type '" "struct DmDiff *""'"); 
  }
  arg1 = (struct DmDiff *)(argp1);
  result = (struct Qmarray **) ((arg1)->dA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DmDiff_dF_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmDiff *arg1 = (struct DmDiff *) 0 ;
  struct Qmarray **arg2 = (struct Qmarray **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DmDiff_dF_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DmDiff_dF_set" "', argument " "1"" of type '" "struct DmDiff *""'"); 
  }
  arg1 = (struct DmDiff *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DmDiff_dF_set" "', argument " "2"" of type '" "struct Qmarray **""'"); 
  }
  arg2 = (struct Qmarray **)(argp2);
  if (arg1) (arg1)->dF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DmDiff_dF_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmDiff *arg1 = (struct DmDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Qmarray **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DmDiff_dF_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DmDiff_dF_get" "', argument " "1"" of type '" "struct DmDiff *""'"); 
  }
  arg1 = (struct DmDiff *)(argp1);
  result = (struct Qmarray **) ((arg1)->dF);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DmDiff_ddF_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmDiff *arg1 = (struct DmDiff *) 0 ;
  struct Qmarray **arg2 = (struct Qmarray **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DmDiff_ddF_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DmDiff_ddF_set" "', argument " "1"" of type '" "struct DmDiff *""'"); 
  }
  arg1 = (struct DmDiff *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DmDiff_ddF_set" "', argument " "2"" of type '" "struct Qmarray **""'"); 
  }
  arg2 = (struct Qmarray **)(argp2);
  if (arg1) (arg1)->ddF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DmDiff_ddF_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmDiff *arg1 = (struct DmDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Qmarray **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DmDiff_ddF_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DmDiff_ddF_get" "', argument " "1"" of type '" "struct DmDiff *""'"); 
  }
  arg1 = (struct DmDiff *)(argp1);
  result = (struct Qmarray **) ((arg1)->ddF);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DmDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmDiff *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DmDiff")) SWIG_fail;
  result = (struct DmDiff *)calloc(1, sizeof(struct DmDiff));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DmDiff, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DmDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmDiff *arg1 = (struct DmDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DmDiff",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmDiff, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DmDiff" "', argument " "1"" of type '" "struct DmDiff *""'"); 
  }
  arg1 = (struct DmDiff *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_dmrg_diffusion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  double arg3 ;
  size_t arg4 ;
  double arg5 ;
  int arg6 ;
  struct MultiApproxOpts *arg7 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:dmrg_diffusion",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dmrg_diffusion" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dmrg_diffusion" "', argument " "2"" of type '" "struct FunctionTrain *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dmrg_diffusion" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dmrg_diffusion" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dmrg_diffusion" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dmrg_diffusion" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dmrg_diffusion" "', argument " "7"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg7 = (struct MultiApproxOpts *)(argp7);
  result = (struct FunctionTrain *)dmrg_diffusion(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exact_diffusion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  struct MultiApproxOpts *arg3 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:exact_diffusion",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exact_diffusion" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "exact_diffusion" "', argument " "2"" of type '" "struct FunctionTrain *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "exact_diffusion" "', argument " "3"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg3 = (struct MultiApproxOpts *)(argp3);
  result = (struct FunctionTrain *)exact_diffusion(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exact_laplace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct MultiApproxOpts *arg2 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:exact_laplace",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exact_laplace" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "exact_laplace" "', argument " "2"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg2 = (struct MultiApproxOpts *)(argp2);
  result = (struct FunctionTrain *)exact_laplace(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exact_laplace_periodic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct MultiApproxOpts *arg2 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:exact_laplace_periodic",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exact_laplace_periodic" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "exact_laplace_periodic" "', argument " "2"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg2 = (struct MultiApproxOpts *)(argp2);
  result = (struct FunctionTrain *)exact_laplace_periodic(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exact_laplace_op(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct Operator **arg2 = (struct Operator **) 0 ;
  struct MultiApproxOpts *arg3 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:exact_laplace_op",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exact_laplace_op" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Operator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "exact_laplace_op" "', argument " "2"" of type '" "struct Operator **""'"); 
  }
  arg2 = (struct Operator **)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "exact_laplace_op" "', argument " "3"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg3 = (struct MultiApproxOpts *)(argp3);
  result = (struct FunctionTrain *)exact_laplace_op(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QR_right_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct QR *arg1 = (struct QR *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:QR_right_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_QR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QR_right_set" "', argument " "1"" of type '" "struct QR *""'"); 
  }
  arg1 = (struct QR *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QR_right_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->right = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QR_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct QR *arg1 = (struct QR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:QR_right_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_QR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QR_right_get" "', argument " "1"" of type '" "struct QR *""'"); 
  }
  arg1 = (struct QR *)(argp1);
  result = (int) ((arg1)->right);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QR_mat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct QR *arg1 = (struct QR *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:QR_mat_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_QR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QR_mat_set" "', argument " "1"" of type '" "struct QR *""'"); 
  }
  arg1 = (struct QR *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QR_mat_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->mat = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QR_mat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct QR *arg1 = (struct QR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:QR_mat_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_QR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QR_mat_get" "', argument " "1"" of type '" "struct QR *""'"); 
  }
  arg1 = (struct QR *)(argp1);
  result = (double *) ((arg1)->mat);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QR_mr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct QR *arg1 = (struct QR *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:QR_mr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_QR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QR_mr_set" "', argument " "1"" of type '" "struct QR *""'"); 
  }
  arg1 = (struct QR *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QR_mr_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->mr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QR_mr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct QR *arg1 = (struct QR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:QR_mr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_QR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QR_mr_get" "', argument " "1"" of type '" "struct QR *""'"); 
  }
  arg1 = (struct QR *)(argp1);
  result = (size_t) ((arg1)->mr);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QR_mc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct QR *arg1 = (struct QR *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:QR_mc_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_QR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QR_mc_set" "', argument " "1"" of type '" "struct QR *""'"); 
  }
  arg1 = (struct QR *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QR_mc_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->mc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QR_mc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct QR *arg1 = (struct QR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:QR_mc_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_QR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QR_mc_get" "', argument " "1"" of type '" "struct QR *""'"); 
  }
  arg1 = (struct QR *)(argp1);
  result = (size_t) ((arg1)->mc);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QR_Q_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct QR *arg1 = (struct QR *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:QR_Q_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_QR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QR_Q_set" "', argument " "1"" of type '" "struct QR *""'"); 
  }
  arg1 = (struct QR *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QR_Q_set" "', argument " "2"" of type '" "struct Qmarray *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  if (arg1) (arg1)->Q = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QR_Q_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct QR *arg1 = (struct QR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:QR_Q_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_QR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QR_Q_get" "', argument " "1"" of type '" "struct QR *""'"); 
  }
  arg1 = (struct QR *)(argp1);
  result = (struct Qmarray *) ((arg1)->Q);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct QR *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QR")) SWIG_fail;
  result = (struct QR *)calloc(1, sizeof(struct QR));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QR, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct QR *arg1 = (struct QR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_QR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QR" "', argument " "1"" of type '" "struct QR *""'"); 
  }
  arg1 = (struct QR *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_qr_reduced(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  int arg2 ;
  struct OneApproxOpts *arg3 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct QR *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qr_reduced",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qr_reduced" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qr_reduced" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qr_reduced" "', argument " "3"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg3 = (struct OneApproxOpts *)(argp3);
  result = (struct QR *)qr_reduced((struct Qmarray const *)arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qr_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct QR *arg1 = (struct QR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qr_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_QR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qr_free" "', argument " "1"" of type '" "struct QR *""'"); 
  }
  arg1 = (struct QR *)(argp1);
  qr_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qr_array_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct QR **arg1 = (struct QR **) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qr_array_free",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_QR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qr_array_free" "', argument " "1"" of type '" "struct QR **""'"); 
  }
  arg1 = (struct QR **)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qr_array_free" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  qr_array_free(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qr_array_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct QR **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qr_array_alloc",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "qr_array_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct QR **)qr_array_alloc(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_QR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dmrg_approx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void (*arg2)(char,size_t,size_t,double *,struct Qmarray **,void *) = (void (*)(char,size_t,size_t,double *,struct Qmarray **,void *)) 0 ;
  void *arg3 = (void *) 0 ;
  double arg4 ;
  size_t arg5 ;
  double arg6 ;
  int arg7 ;
  struct MultiApproxOpts *arg8 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:dmrg_approx",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dmrg_approx" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_char_unsigned_long_unsigned_long_p_double_p_p_struct_Qmarray_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "dmrg_approx" "', argument " "2"" of type '" "void (*)(char,size_t,size_t,double *,struct Qmarray **,void *)""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dmrg_approx" "', argument " "3"" of type '" "void *""'"); 
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dmrg_approx" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dmrg_approx" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dmrg_approx" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = (double)(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "dmrg_approx" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = (int)(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dmrg_approx" "', argument " "8"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg8 = (struct MultiApproxOpts *)(argp8);
  result = (struct FunctionTrain *)dmrg_approx(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DmProd_a_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmProd *arg1 = (struct DmProd *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DmProd_a_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmProd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DmProd_a_set" "', argument " "1"" of type '" "struct DmProd *""'"); 
  }
  arg1 = (struct DmProd *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DmProd_a_set" "', argument " "2"" of type '" "struct FunctionTrain *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  if (arg1) (arg1)->a = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DmProd_a_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmProd *arg1 = (struct DmProd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DmProd_a_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmProd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DmProd_a_get" "', argument " "1"" of type '" "struct DmProd *""'"); 
  }
  arg1 = (struct DmProd *)(argp1);
  result = (struct FunctionTrain *) ((arg1)->a);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DmProd_b_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmProd *arg1 = (struct DmProd *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DmProd_b_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmProd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DmProd_b_set" "', argument " "1"" of type '" "struct DmProd *""'"); 
  }
  arg1 = (struct DmProd *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DmProd_b_set" "', argument " "2"" of type '" "struct FunctionTrain *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  if (arg1) (arg1)->b = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DmProd_b_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmProd *arg1 = (struct DmProd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DmProd_b_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmProd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DmProd_b_get" "', argument " "1"" of type '" "struct DmProd *""'"); 
  }
  arg1 = (struct DmProd *)(argp1);
  result = (struct FunctionTrain *) ((arg1)->b);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DmProd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmProd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DmProd")) SWIG_fail;
  result = (struct DmProd *)calloc(1, sizeof(struct DmProd));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DmProd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DmProd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct DmProd *arg1 = (struct DmProd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DmProd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DmProd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DmProd" "', argument " "1"" of type '" "struct DmProd *""'"); 
  }
  arg1 = (struct DmProd *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_dmrg_product(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  struct FunctionTrain *arg3 = (struct FunctionTrain *) 0 ;
  double arg4 ;
  size_t arg5 ;
  double arg6 ;
  int arg7 ;
  struct MultiApproxOpts *arg8 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:dmrg_product",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dmrg_product" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dmrg_product" "', argument " "2"" of type '" "struct FunctionTrain *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dmrg_product" "', argument " "3"" of type '" "struct FunctionTrain *""'"); 
  }
  arg3 = (struct FunctionTrain *)(argp3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dmrg_product" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dmrg_product" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dmrg_product" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = (double)(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "dmrg_product" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = (int)(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dmrg_product" "', argument " "8"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg8 = (struct MultiApproxOpts *)(argp8);
  result = (struct FunctionTrain *)dmrg_product(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_dim_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionTrain_dim_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_dim_set" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FunctionTrain_dim_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->dim = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_dim_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionTrain_dim_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_dim_get" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (size_t) ((arg1)->dim);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_ranks_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionTrain_ranks_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_ranks_set" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  {
    if (!PyList_Check(obj1)) {
      PyErr_SetString(PyExc_ValueError,"Expecting a list");
      return NULL;
    }
    int size = PyList_Size(obj1);
    arg2 = (size_t *) malloc(size * sizeof(size_t));
    for (int i = 0; i < size; i++){
      PyObject *s = PyList_GetItem(obj1,i);
      if (!PyInt_Check(s)) {
        free(arg2);
        PyErr_SetString(PyExc_ValueError, "List items must be integers");
        return NULL;
      }
      arg2[i] = PyInt_AsLong(s);
    }
  }
  if (arg1) (arg1)->ranks = arg2;
  resultobj = SWIG_Py_Void();
  {
    if (arg2) free(arg2);
  }
  return resultobj;
fail:
  {
    if (arg2) free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_ranks_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionTrain_ranks_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_ranks_get" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (size_t *) ((arg1)->ranks);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_cores_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct Qmarray **arg2 = (struct Qmarray **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionTrain_cores_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_cores_set" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionTrain_cores_set" "', argument " "2"" of type '" "struct Qmarray **""'"); 
  }
  arg2 = (struct Qmarray **)(argp2);
  if (arg1) (arg1)->cores = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_cores_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Qmarray **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionTrain_cores_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_cores_get" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (struct Qmarray **) ((arg1)->cores);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evalspace1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct FTMemSpace *arg2 = (struct FTMemSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionTrain_evalspace1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evalspace1_set" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FTMemSpace, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionTrain_evalspace1_set" "', argument " "2"" of type '" "struct FTMemSpace *""'"); 
  }
  arg2 = (struct FTMemSpace *)(argp2);
  if (arg1) (arg1)->evalspace1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evalspace1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FTMemSpace *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionTrain_evalspace1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evalspace1_get" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (struct FTMemSpace *) ((arg1)->evalspace1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTMemSpace, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evalspace2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct FTMemSpace *arg2 = (struct FTMemSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionTrain_evalspace2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evalspace2_set" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FTMemSpace, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionTrain_evalspace2_set" "', argument " "2"" of type '" "struct FTMemSpace *""'"); 
  }
  arg2 = (struct FTMemSpace *)(argp2);
  if (arg1) (arg1)->evalspace2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evalspace2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FTMemSpace *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionTrain_evalspace2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evalspace2_get" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (struct FTMemSpace *) ((arg1)->evalspace2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTMemSpace, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evalspace3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct FTMemSpace *arg2 = (struct FTMemSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionTrain_evalspace3_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evalspace3_set" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FTMemSpace, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionTrain_evalspace3_set" "', argument " "2"" of type '" "struct FTMemSpace *""'"); 
  }
  arg2 = (struct FTMemSpace *)(argp2);
  if (arg1) (arg1)->evalspace3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evalspace3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FTMemSpace *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionTrain_evalspace3_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evalspace3_get" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (struct FTMemSpace *) ((arg1)->evalspace3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTMemSpace, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evalspace4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct FTMemSpace **arg2 = (struct FTMemSpace **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionTrain_evalspace4_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evalspace4_set" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_FTMemSpace, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionTrain_evalspace4_set" "', argument " "2"" of type '" "struct FTMemSpace **""'"); 
  }
  arg2 = (struct FTMemSpace **)(argp2);
  if (arg1) (arg1)->evalspace4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evalspace4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FTMemSpace **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionTrain_evalspace4_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evalspace4_get" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (struct FTMemSpace **) ((arg1)->evalspace4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_FTMemSpace, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evaldd1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  double **arg2 = (double **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionTrain_evaldd1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evaldd1_set" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionTrain_evaldd1_set" "', argument " "2"" of type '" "double **""'"); 
  }
  arg2 = (double **)(argp2);
  if (arg1) (arg1)->evaldd1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evaldd1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionTrain_evaldd1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evaldd1_get" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (double **) ((arg1)->evaldd1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evaldd2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  double **arg2 = (double **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionTrain_evaldd2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evaldd2_set" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionTrain_evaldd2_set" "', argument " "2"" of type '" "double **""'"); 
  }
  arg2 = (double **)(argp2);
  if (arg1) (arg1)->evaldd2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evaldd2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionTrain_evaldd2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evaldd2_get" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (double **) ((arg1)->evaldd2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evaldd3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  double **arg2 = (double **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionTrain_evaldd3_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evaldd3_set" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionTrain_evaldd3_set" "', argument " "2"" of type '" "double **""'"); 
  }
  arg2 = (double **)(argp2);
  if (arg1) (arg1)->evaldd3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evaldd3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionTrain_evaldd3_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evaldd3_get" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (double **) ((arg1)->evaldd3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evaldd4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  double **arg2 = (double **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionTrain_evaldd4_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evaldd4_set" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionTrain_evaldd4_set" "', argument " "2"" of type '" "double **""'"); 
  }
  arg2 = (double **)(argp2);
  if (arg1) (arg1)->evaldd4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionTrain_evaldd4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionTrain_evaldd4_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionTrain_evaldd4_get" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (double **) ((arg1)->evaldd4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FunctionTrain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FunctionTrain")) SWIG_fail;
  result = (struct FunctionTrain *)calloc(1, sizeof(struct FunctionTrain));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FunctionTrain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FunctionTrain",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FunctionTrain" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_function_train_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_copy" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (struct FunctionTrain *)function_train_copy((struct FunctionTrain const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:function_train_serialize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_serialize" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_serialize" "', argument " "2"" of type '" "struct FunctionTrain *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "function_train_serialize" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (unsigned char *)function_train_serialize(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_deserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct FunctionTrain **arg2 = (struct FunctionTrain **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_deserialize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_deserialize" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_deserialize" "', argument " "2"" of type '" "struct FunctionTrain **""'"); 
  }
  arg2 = (struct FunctionTrain **)(argp2);
  result = (unsigned char *)function_train_deserialize(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_savetxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:function_train_savetxt",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_savetxt" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_savetxt" "', argument " "2"" of type '" "FILE *""'"); 
  }
  arg2 = (FILE *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "function_train_savetxt" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  function_train_savetxt(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_loadtxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FILE *arg1 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_loadtxt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_loadtxt" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = (FILE *)(argp1);
  result = (struct FunctionTrain *)function_train_loadtxt(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_save",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_save" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_save" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  result = (int)function_train_save(arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_load",&obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_load" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  result = (struct FunctionTrain *)function_train_load(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_get_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_get_dim",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_get_dim" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (size_t)function_train_get_dim((struct FunctionTrain const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_get_ranks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_get_ranks",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_get_ranks" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (size_t *)function_train_get_ranks((struct FunctionTrain const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_get_maxrank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_get_maxrank",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_get_maxrank" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (size_t)function_train_get_maxrank((struct FunctionTrain const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_get_avgrank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_get_avgrank",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_get_avgrank" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (double)function_train_get_avgrank((struct FunctionTrain const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_get_core(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_get_core",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_get_core" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_get_core" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (struct Qmarray *)function_train_get_core((struct FunctionTrain const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_eval_up_to_core(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  size_t *arg5 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:function_train_eval_up_to_core",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_eval_up_to_core" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_eval_up_to_core" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "function_train_eval_up_to_core" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "function_train_eval_up_to_core" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "function_train_eval_up_to_core" "', argument " "5"" of type '" "size_t *""'"); 
  }
  arg5 = (size_t *)(argp5);
  function_train_eval_up_to_core(arg1,arg2,(double const *)arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_func_get_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t 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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:function_train_func_get_nparams",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_func_get_nparams" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_func_get_nparams" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "function_train_func_get_nparams" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "function_train_func_get_nparams" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  result = (size_t)function_train_func_get_nparams((struct FunctionTrain const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_core_get_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:function_train_core_get_nparams",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_core_get_nparams" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_core_get_nparams" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "function_train_core_get_nparams" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (size_t)function_train_core_get_nparams((struct FunctionTrain const *)arg1,arg2,arg3);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_get_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_get_nparams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_get_nparams" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (size_t)function_train_get_nparams((struct FunctionTrain const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_core_get_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:function_train_core_get_params",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_core_get_params" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_core_get_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "function_train_core_get_params" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (size_t)function_train_core_get_params((struct FunctionTrain const *)arg1,arg2,arg3);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_get_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_get_params",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_get_params" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_get_params" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (size_t)function_train_get_params((struct FunctionTrain const *)arg1,arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_get_uni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t 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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  void *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:function_train_get_uni",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_get_uni" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_get_uni" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "function_train_get_uni" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "function_train_get_uni" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  result = (void *)function_train_get_uni((struct FunctionTrain const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_get_gfuni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t 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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:function_train_get_gfuni",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_get_gfuni" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_get_gfuni" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "function_train_get_gfuni" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "function_train_get_gfuni" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  result = (struct GenericFunction *)function_train_get_gfuni((struct FunctionTrain const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_uni_update_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  double *arg6 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:function_train_uni_update_params",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_uni_update_params" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_uni_update_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "function_train_uni_update_params" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "function_train_uni_update_params" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "function_train_uni_update_params" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "function_train_uni_update_params" "', argument " "6"" of type '" "double const *""'"); 
  }
  arg6 = (double *)(argp6);
  function_train_uni_update_params(arg1,arg2,arg3,arg4,arg5,(double const *)arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_core_update_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  double *arg4 = (double *) 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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:function_train_core_update_params",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_core_update_params" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_core_update_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "function_train_core_update_params" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "function_train_core_update_params" "', argument " "4"" of type '" "double const *""'"); 
  }
  arg4 = (double *)(argp4);
  function_train_core_update_params(arg1,arg2,arg3,(double const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_update_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_update_params",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_update_params" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_update_params" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (size_t)function_train_update_params(arg1,(double const *)arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_param_grad_sqnorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:function_train_param_grad_sqnorm",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_param_grad_sqnorm" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_param_grad_sqnorm" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "function_train_param_grad_sqnorm" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (double)function_train_param_grad_sqnorm(arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_eval_ind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_eval_ind",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_eval_ind" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_eval_ind" "', argument " "2"" of type '" "size_t const *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (double)function_train_eval_ind(arg1,(unsigned long const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_eval_co_perturb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:function_train_eval_co_perturb",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_eval_co_perturb" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_eval_co_perturb" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "function_train_eval_co_perturb" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "function_train_eval_co_perturb" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (double)function_train_eval_co_perturb(arg1,(double const *)arg2,(double const *)arg3,arg4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_eval_co_perturb_ind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  double *arg4 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:function_train_eval_co_perturb_ind",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_eval_co_perturb_ind" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_eval_co_perturb_ind" "', argument " "2"" of type '" "size_t const *""'"); 
  }
  arg2 = (size_t *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "function_train_eval_co_perturb_ind" "', argument " "3"" of type '" "size_t const *""'"); 
  }
  arg3 = (size_t *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "function_train_eval_co_perturb_ind" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (double)function_train_eval_co_perturb_ind(arg1,(unsigned long const *)arg2,(unsigned long const *)arg3,arg4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_eval_fiber_ind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  size_t arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  size_t arg5 ;
  double *arg6 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:function_train_eval_fiber_ind",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_eval_fiber_ind" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_eval_fiber_ind" "', argument " "2"" of type '" "size_t const *""'"); 
  }
  arg2 = (size_t *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "function_train_eval_fiber_ind" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "function_train_eval_fiber_ind" "', argument " "4"" of type '" "size_t const *""'"); 
  }
  arg4 = (size_t *)(argp4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "function_train_eval_fiber_ind" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "function_train_eval_fiber_ind" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  function_train_eval_fiber_ind(arg1,(unsigned long const *)arg2,arg3,(unsigned long const *)arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_poly_randu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum poly_type arg1 ;
  struct BoundingBox *arg2 = (struct BoundingBox *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  size_t arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:function_train_poly_randu",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "function_train_poly_randu" "', argument " "1"" of type '" "enum poly_type""'");
  } 
  arg1 = (enum poly_type)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_BoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_poly_randu" "', argument " "2"" of type '" "struct BoundingBox *""'"); 
  }
  arg2 = (struct BoundingBox *)(argp2);
  {
    if (!PyList_Check(obj2)) {
      PyErr_SetString(PyExc_ValueError,"Expecting a list");
      return NULL;
    }
    int size = PyList_Size(obj2);
    arg3 = (size_t *) malloc(size * sizeof(size_t));
    for (int i = 0; i < size; i++){
      PyObject *s = PyList_GetItem(obj2,i);
      if (!PyInt_Check(s)) {
        free(arg3);
        PyErr_SetString(PyExc_ValueError, "List items must be integers");
        return NULL;
      }
      arg3[i] = PyInt_AsLong(s);
    }
  }
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "function_train_poly_randu" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  result = (struct FunctionTrain *)function_train_poly_randu(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  {
    if (arg3) free(arg3);
  }
  return resultobj;
fail:
  {
    if (arg3) free(arg3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_rankone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  struct Fwrap *arg2 = (struct Fwrap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_rankone",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_rankone" "', argument " "1"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_rankone" "', argument " "2"" of type '" "struct Fwrap *""'"); 
  }
  arg2 = (struct Fwrap *)(argp2);
  result = (struct FunctionTrain *)function_train_rankone(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_initsum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  struct Fwrap *arg2 = (struct Fwrap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_initsum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_initsum" "', argument " "1"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_initsum" "', argument " "2"" of type '" "struct Fwrap *""'"); 
  }
  arg2 = (struct Fwrap *)(argp2);
  result = (struct FunctionTrain *)function_train_initsum(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_zeros",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_zeros" "', argument " "1"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_zeros" "', argument " "2"" of type '" "size_t const *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (struct FunctionTrain *)function_train_zeros(arg1,(unsigned long const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_constant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct MultiApproxOpts *arg2 = (struct MultiApproxOpts *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_constant",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "function_train_constant" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_constant" "', argument " "2"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg2 = (struct MultiApproxOpts *)(argp2);
  result = (struct FunctionTrain *)function_train_constant(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_linear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  struct MultiApproxOpts *arg5 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:function_train_linear",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_linear" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = (double *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_linear" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "function_train_linear" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "function_train_linear" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "function_train_linear" "', argument " "5"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg5 = (struct MultiApproxOpts *)(argp5);
  result = (struct FunctionTrain *)function_train_linear((double const *)arg1,arg2,(double const *)arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_linear_update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  double *arg2 = (double *) 0 ;
  size_t arg3 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:function_train_linear_update",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_linear_update" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_linear_update" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "function_train_linear_update" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "function_train_linear_update" "', argument " "4"" of type '" "double const *""'"); 
  }
  arg4 = (double *)(argp4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "function_train_linear_update" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  result = (int)function_train_linear_update(arg1,(double const *)arg2,arg3,(double const *)arg4,arg5);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_rankone_prod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  struct MultiApproxOpts *arg2 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_rankone_prod",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_rankone_prod" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = (double *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_rankone_prod" "', argument " "2"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg2 = (struct MultiApproxOpts *)(argp2);
  result = (struct FunctionTrain *)function_train_rankone_prod((double const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_quadratic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  double *arg2 = (double *) 0 ;
  struct MultiApproxOpts *arg3 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:function_train_quadratic",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_quadratic" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = (double *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_quadratic" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "function_train_quadratic" "', argument " "3"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg3 = (struct MultiApproxOpts *)(argp3);
  result = (struct FunctionTrain *)function_train_quadratic((double const *)arg1,(double const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_quadratic_aligned(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  double *arg2 = (double *) 0 ;
  struct MultiApproxOpts *arg3 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:function_train_quadratic_aligned",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_quadratic_aligned" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = (double *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_quadratic_aligned" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "function_train_quadratic_aligned" "', argument " "3"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg3 = (struct MultiApproxOpts *)(argp3);
  result = (struct FunctionTrain *)function_train_quadratic_aligned((double const *)arg1,(double const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_create_nodal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  double **arg3 = (double **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:function_train_create_nodal",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_create_nodal" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_create_nodal" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "function_train_create_nodal" "', argument " "3"" of type '" "double **""'"); 
  }
  arg3 = (double **)(argp3);
  result = (struct FunctionTrain *)function_train_create_nodal((struct FunctionTrain const *)arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_integrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_integrate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_integrate" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (double)function_train_integrate((struct FunctionTrain const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_integrate_weighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_integrate_weighted",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_integrate_weighted" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (double)function_train_integrate_weighted((struct FunctionTrain const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_integrate_weighted_subset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:function_train_integrate_weighted_subset",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_integrate_weighted_subset" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_integrate_weighted_subset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "function_train_integrate_weighted_subset" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (struct FunctionTrain *)function_train_integrate_weighted_subset((struct FunctionTrain const *)arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_inner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_inner",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_inner" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_inner" "', argument " "2"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  result = (double)function_train_inner((struct FunctionTrain const *)arg1,(struct FunctionTrain const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_inner_weighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_inner_weighted",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_inner_weighted" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_inner_weighted" "', argument " "2"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  result = (double)function_train_inner_weighted((struct FunctionTrain const *)arg1,(struct FunctionTrain const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_norm2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_norm2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_norm2" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (double)function_train_norm2((struct FunctionTrain const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_orthor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct MultiApproxOpts *arg2 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_orthor",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_orthor" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_orthor" "', argument " "2"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg2 = (struct MultiApproxOpts *)(argp2);
  result = (struct FunctionTrain *)function_train_orthor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_round(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  double arg2 ;
  struct MultiApproxOpts *arg3 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:function_train_round",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_round" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_round" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "function_train_round" "', argument " "3"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg3 = (struct MultiApproxOpts *)(argp3);
  result = (struct FunctionTrain *)function_train_round(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_truncate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_truncate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_truncate" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_truncate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  function_train_truncate(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_sum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_sum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_sum" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_sum" "', argument " "2"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  result = (struct FunctionTrain *)function_train_sum((struct FunctionTrain const *)arg1,(struct FunctionTrain const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_scale",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_scale" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_scale" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  function_train_scale(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_product(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_product",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_product" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_product" "', argument " "2"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  result = (struct FunctionTrain *)function_train_product((struct FunctionTrain const *)arg1,(struct FunctionTrain const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_norm2diff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_norm2diff",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_norm2diff" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_norm2diff" "', argument " "2"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  result = (double)function_train_norm2diff((struct FunctionTrain const *)arg1,(struct FunctionTrain const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_relnorm2diff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_relnorm2diff",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_relnorm2diff" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_relnorm2diff" "', argument " "2"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  result = (double)function_train_relnorm2diff((struct FunctionTrain const *)arg1,(struct FunctionTrain const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_is_kristoffel_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_is_kristoffel_active",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_is_kristoffel_active" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (int)function_train_is_kristoffel_active((struct FunctionTrain const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_activate_kristoffel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_activate_kristoffel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_activate_kristoffel" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  function_train_activate_kristoffel(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_deactivate_kristoffel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_deactivate_kristoffel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_deactivate_kristoffel" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  function_train_deactivate_kristoffel(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_get_kristoffel_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_get_kristoffel_weight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_get_kristoffel_weight" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_get_kristoffel_weight" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (double)function_train_get_kristoffel_weight((struct FunctionTrain const *)arg1,(double const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_cross_args_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct FtCrossArgs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_cross_args_alloc",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ft_cross_args_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_cross_args_alloc" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (struct FtCrossArgs *)ft_cross_args_alloc(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_cross_args_set_rank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FtCrossArgs *arg1 = (struct FtCrossArgs *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ft_cross_args_set_rank",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_cross_args_set_rank" "', argument " "1"" of type '" "struct FtCrossArgs *""'"); 
  }
  arg1 = (struct FtCrossArgs *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_cross_args_set_rank" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ft_cross_args_set_rank" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ft_cross_args_set_rank(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_cross_args_set_round_tol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FtCrossArgs *arg1 = (struct FtCrossArgs *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_cross_args_set_round_tol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_cross_args_set_round_tol" "', argument " "1"" of type '" "struct FtCrossArgs *""'"); 
  }
  arg1 = (struct FtCrossArgs *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_cross_args_set_round_tol" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ft_cross_args_set_round_tol(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_cross_args_set_kickrank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FtCrossArgs *arg1 = (struct FtCrossArgs *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_cross_args_set_kickrank",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_cross_args_set_kickrank" "', argument " "1"" of type '" "struct FtCrossArgs *""'"); 
  }
  arg1 = (struct FtCrossArgs *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_cross_args_set_kickrank" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ft_cross_args_set_kickrank(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_cross_args_set_maxiter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FtCrossArgs *arg1 = (struct FtCrossArgs *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_cross_args_set_maxiter",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_cross_args_set_maxiter" "', argument " "1"" of type '" "struct FtCrossArgs *""'"); 
  }
  arg1 = (struct FtCrossArgs *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_cross_args_set_maxiter" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ft_cross_args_set_maxiter(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_cross_args_set_no_adaptation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FtCrossArgs *arg1 = (struct FtCrossArgs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft_cross_args_set_no_adaptation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_cross_args_set_no_adaptation" "', argument " "1"" of type '" "struct FtCrossArgs *""'"); 
  }
  arg1 = (struct FtCrossArgs *)(argp1);
  ft_cross_args_set_no_adaptation(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_cross_args_set_adaptation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FtCrossArgs *arg1 = (struct FtCrossArgs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft_cross_args_set_adaptation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_cross_args_set_adaptation" "', argument " "1"" of type '" "struct FtCrossArgs *""'"); 
  }
  arg1 = (struct FtCrossArgs *)(argp1);
  ft_cross_args_set_adaptation(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_cross_args_set_maxrank_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FtCrossArgs *arg1 = (struct FtCrossArgs *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_cross_args_set_maxrank_all",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_cross_args_set_maxrank_all" "', argument " "1"" of type '" "struct FtCrossArgs *""'"); 
  }
  arg1 = (struct FtCrossArgs *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_cross_args_set_maxrank_all" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ft_cross_args_set_maxrank_all(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_cross_args_set_maxrank_ind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FtCrossArgs *arg1 = (struct FtCrossArgs *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ft_cross_args_set_maxrank_ind",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_cross_args_set_maxrank_ind" "', argument " "1"" of type '" "struct FtCrossArgs *""'"); 
  }
  arg1 = (struct FtCrossArgs *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_cross_args_set_maxrank_ind" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ft_cross_args_set_maxrank_ind" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ft_cross_args_set_maxrank_ind(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_cross_args_set_cross_tol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FtCrossArgs *arg1 = (struct FtCrossArgs *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_cross_args_set_cross_tol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_cross_args_set_cross_tol" "', argument " "1"" of type '" "struct FtCrossArgs *""'"); 
  }
  arg1 = (struct FtCrossArgs *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_cross_args_set_cross_tol" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ft_cross_args_set_cross_tol(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_cross_args_set_verbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FtCrossArgs *arg1 = (struct FtCrossArgs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft_cross_args_set_verbose",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_cross_args_set_verbose" "', argument " "1"" of type '" "struct FtCrossArgs *""'"); 
  }
  arg1 = (struct FtCrossArgs *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft_cross_args_set_verbose" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ft_cross_args_set_verbose(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_cross_args_get_ranks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FtCrossArgs *arg1 = (struct FtCrossArgs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft_cross_args_get_ranks",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_cross_args_get_ranks" "', argument " "1"" of type '" "struct FtCrossArgs const *""'"); 
  }
  arg1 = (struct FtCrossArgs *)(argp1);
  result = (size_t *)ft_cross_args_get_ranks((struct FtCrossArgs const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_get_rank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_train_get_rank",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_get_rank" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "function_train_get_rank" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (size_t)function_train_get_rank((struct FunctionTrain const *)arg1,arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_cross_args_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FtCrossArgs *arg1 = (struct FtCrossArgs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FtCrossArgs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft_cross_args_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_cross_args_copy" "', argument " "1"" of type '" "struct FtCrossArgs const *""'"); 
  }
  arg1 = (struct FtCrossArgs *)(argp1);
  result = (struct FtCrossArgs *)ft_cross_args_copy((struct FtCrossArgs const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft_cross_args_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FtCrossArgs *arg1 = (struct FtCrossArgs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft_cross_args_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft_cross_args_free" "', argument " "1"" of type '" "struct FtCrossArgs *""'"); 
  }
  arg1 = (struct FtCrossArgs *)(argp1);
  ft_cross_args_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_init_from_fibers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  struct CrossIndex **arg3 = (struct CrossIndex **) 0 ;
  struct CrossIndex **arg4 = (struct CrossIndex **) 0 ;
  struct MultiApproxOpts *arg5 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:function_train_init_from_fibers",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_init_from_fibers" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_train_init_from_fibers" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "function_train_init_from_fibers" "', argument " "3"" of type '" "struct CrossIndex **""'"); 
  }
  arg3 = (struct CrossIndex **)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "function_train_init_from_fibers" "', argument " "4"" of type '" "struct CrossIndex **""'"); 
  }
  arg4 = (struct CrossIndex **)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "function_train_init_from_fibers" "', argument " "5"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg5 = (struct MultiApproxOpts *)(argp5);
  result = (struct FunctionTrain *)function_train_init_from_fibers(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ftapprox_cross(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  struct FtCrossArgs *arg2 = (struct FtCrossArgs *) 0 ;
  struct CrossIndex **arg3 = (struct CrossIndex **) 0 ;
  struct CrossIndex **arg4 = (struct CrossIndex **) 0 ;
  struct MultiApproxOpts *arg5 = (struct MultiApproxOpts *) 0 ;
  struct FiberOptArgs *arg6 = (struct FiberOptArgs *) 0 ;
  struct FunctionTrain *arg7 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ftapprox_cross",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ftapprox_cross" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ftapprox_cross" "', argument " "2"" of type '" "struct FtCrossArgs *""'"); 
  }
  arg2 = (struct FtCrossArgs *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ftapprox_cross" "', argument " "3"" of type '" "struct CrossIndex **""'"); 
  }
  arg3 = (struct CrossIndex **)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ftapprox_cross" "', argument " "4"" of type '" "struct CrossIndex **""'"); 
  }
  arg4 = (struct CrossIndex **)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ftapprox_cross" "', argument " "5"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg5 = (struct MultiApproxOpts *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_FiberOptArgs, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ftapprox_cross" "', argument " "6"" of type '" "struct FiberOptArgs *""'"); 
  }
  arg6 = (struct FiberOptArgs *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ftapprox_cross" "', argument " "7"" of type '" "struct FunctionTrain *""'"); 
  }
  arg7 = (struct FunctionTrain *)(argp7);
  result = (struct FunctionTrain *)ftapprox_cross(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ftapprox_cross_rankadapt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  struct FtCrossArgs *arg2 = (struct FtCrossArgs *) 0 ;
  struct CrossIndex **arg3 = (struct CrossIndex **) 0 ;
  struct CrossIndex **arg4 = (struct CrossIndex **) 0 ;
  struct MultiApproxOpts *arg5 = (struct MultiApproxOpts *) 0 ;
  struct FiberOptArgs *arg6 = (struct FiberOptArgs *) 0 ;
  struct FunctionTrain *arg7 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ftapprox_cross_rankadapt",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ftapprox_cross_rankadapt" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FtCrossArgs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ftapprox_cross_rankadapt" "', argument " "2"" of type '" "struct FtCrossArgs *""'"); 
  }
  arg2 = (struct FtCrossArgs *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ftapprox_cross_rankadapt" "', argument " "3"" of type '" "struct CrossIndex **""'"); 
  }
  arg3 = (struct CrossIndex **)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ftapprox_cross_rankadapt" "', argument " "4"" of type '" "struct CrossIndex **""'"); 
  }
  arg4 = (struct CrossIndex **)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ftapprox_cross_rankadapt" "', argument " "5"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg5 = (struct MultiApproxOpts *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_FiberOptArgs, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ftapprox_cross_rankadapt" "', argument " "6"" of type '" "struct FiberOptArgs *""'"); 
  }
  arg6 = (struct FiberOptArgs *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ftapprox_cross_rankadapt" "', argument " "7"" of type '" "struct FunctionTrain *""'"); 
  }
  arg7 = (struct FunctionTrain *)(argp7);
  result = (struct FunctionTrain *)ftapprox_cross_rankadapt(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FT1DArray_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FT1DArray *arg1 = (struct FT1DArray *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FT1DArray_size_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FT1DArray_size_set" "', argument " "1"" of type '" "struct FT1DArray *""'"); 
  }
  arg1 = (struct FT1DArray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FT1DArray_size_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FT1DArray_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FT1DArray *arg1 = (struct FT1DArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FT1DArray_size_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FT1DArray_size_get" "', argument " "1"" of type '" "struct FT1DArray *""'"); 
  }
  arg1 = (struct FT1DArray *)(argp1);
  result = (size_t) ((arg1)->size);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FT1DArray_ft_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FT1DArray *arg1 = (struct FT1DArray *) 0 ;
  struct FunctionTrain **arg2 = (struct FunctionTrain **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FT1DArray_ft_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FT1DArray_ft_set" "', argument " "1"" of type '" "struct FT1DArray *""'"); 
  }
  arg1 = (struct FT1DArray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FT1DArray_ft_set" "', argument " "2"" of type '" "struct FunctionTrain **""'"); 
  }
  arg2 = (struct FunctionTrain **)(argp2);
  if (arg1) (arg1)->ft = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FT1DArray_ft_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FT1DArray *arg1 = (struct FT1DArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FunctionTrain **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FT1DArray_ft_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FT1DArray_ft_get" "', argument " "1"" of type '" "struct FT1DArray *""'"); 
  }
  arg1 = (struct FT1DArray *)(argp1);
  result = (struct FunctionTrain **) ((arg1)->ft);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FT1DArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FT1DArray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FT1DArray")) SWIG_fail;
  result = (struct FT1DArray *)calloc(1, sizeof(struct FT1DArray));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FT1DArray, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FT1DArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FT1DArray *arg1 = (struct FT1DArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FT1DArray",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FT1DArray, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FT1DArray" "', argument " "1"" of type '" "struct FT1DArray *""'"); 
  }
  arg1 = (struct FT1DArray *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_ft1d_array_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FT1DArray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft1d_array_alloc",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ft1d_array_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct FT1DArray *)ft1d_array_alloc(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FT1DArray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_gradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FT1DArray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_gradient",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_gradient" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (struct FT1DArray *)function_train_gradient((struct FunctionTrain const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FT1DArray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft1d_array_serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct FT1DArray *arg2 = (struct FT1DArray *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ft1d_array_serialize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft1d_array_serialize" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft1d_array_serialize" "', argument " "2"" of type '" "struct FT1DArray *""'"); 
  }
  arg2 = (struct FT1DArray *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ft1d_array_serialize" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (unsigned char *)ft1d_array_serialize(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft1d_array_deserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct FT1DArray **arg2 = (struct FT1DArray **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft1d_array_deserialize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft1d_array_deserialize" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft1d_array_deserialize" "', argument " "2"" of type '" "struct FT1DArray **""'"); 
  }
  arg2 = (struct FT1DArray **)(argp2);
  result = (unsigned char *)ft1d_array_deserialize(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft1d_array_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FT1DArray *arg1 = (struct FT1DArray *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft1d_array_save",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft1d_array_save" "', argument " "1"" of type '" "struct FT1DArray *""'"); 
  }
  arg1 = (struct FT1DArray *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft1d_array_save" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  result = (int)ft1d_array_save(arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft1d_array_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FT1DArray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft1d_array_load",&obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft1d_array_load" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  result = (struct FT1DArray *)ft1d_array_load(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft1d_array_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FT1DArray *arg1 = (struct FT1DArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FT1DArray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft1d_array_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft1d_array_copy" "', argument " "1"" of type '" "struct FT1DArray const *""'"); 
  }
  arg1 = (struct FT1DArray *)(argp1);
  result = (struct FT1DArray *)ft1d_array_copy((struct FT1DArray const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FT1DArray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft1d_array_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FT1DArray *arg1 = (struct FT1DArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft1d_array_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft1d_array_free" "', argument " "1"" of type '" "struct FT1DArray *""'"); 
  }
  arg1 = (struct FT1DArray *)(argp1);
  ft1d_array_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft1d_array_jacobian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FT1DArray *arg1 = (struct FT1DArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FT1DArray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ft1d_array_jacobian",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft1d_array_jacobian" "', argument " "1"" of type '" "struct FT1DArray const *""'"); 
  }
  arg1 = (struct FT1DArray *)(argp1);
  result = (struct FT1DArray *)ft1d_array_jacobian((struct FT1DArray const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FT1DArray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_hessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FT1DArray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_hessian",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_hessian" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (struct FT1DArray *)function_train_hessian((struct FunctionTrain const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FT1DArray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_hessian_diag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FT1DArray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_hessian_diag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_hessian_diag" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (struct FT1DArray *)function_train_hessian_diag((struct FunctionTrain const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FT1DArray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_train_hessian_diag_periodic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FT1DArray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_train_hessian_diag_periodic",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_train_hessian_diag_periodic" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  result = (struct FT1DArray *)function_train_hessian_diag_periodic((struct FunctionTrain const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FT1DArray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft1d_array_scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FT1DArray *arg1 = (struct FT1DArray *) 0 ;
  size_t arg2 ;
  size_t 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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ft1d_array_scale",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft1d_array_scale" "', argument " "1"" of type '" "struct FT1DArray *""'"); 
  }
  arg1 = (struct FT1DArray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ft1d_array_scale" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ft1d_array_scale" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ft1d_array_scale" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  ft1d_array_scale(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft1d_array_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FT1DArray *arg1 = (struct FT1DArray *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ft1d_array_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft1d_array_eval" "', argument " "1"" of type '" "struct FT1DArray const *""'"); 
  }
  arg1 = (struct FT1DArray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft1d_array_eval" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (double *)ft1d_array_eval((struct FT1DArray const *)arg1,(double const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ft1d_array_eval2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FT1DArray *arg1 = (struct FT1DArray *) 0 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ft1d_array_eval2",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ft1d_array_eval2" "', argument " "1"" of type '" "struct FT1DArray const *""'"); 
  }
  arg1 = (struct FT1DArray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ft1d_array_eval2" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ft1d_array_eval2" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  ft1d_array_eval2((struct FT1DArray const *)arg1,(double const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3axpy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  struct FunctionTrain **arg3 = (struct FunctionTrain **) 0 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:c3axpy",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3axpy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3axpy" "', argument " "2"" of type '" "struct FunctionTrain *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3axpy" "', argument " "3"" of type '" "struct FunctionTrain **""'"); 
  }
  arg3 = (struct FunctionTrain **)(argp3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "c3axpy" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  c3axpy(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3vaxpy_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double arg2 ;
  struct FT1DArray *arg3 = (struct FT1DArray *) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  double arg7 ;
  struct FunctionTrain **arg8 = (struct FunctionTrain **) 0 ;
  double arg9 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:c3vaxpy_arr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3vaxpy_arr" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3vaxpy_arr" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3vaxpy_arr" "', argument " "3"" of type '" "struct FT1DArray *""'"); 
  }
  arg3 = (struct FT1DArray *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "c3vaxpy_arr" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "c3vaxpy_arr" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "c3vaxpy_arr" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "c3vaxpy_arr" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = (double)(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "c3vaxpy_arr" "', argument " "8"" of type '" "struct FunctionTrain **""'"); 
  }
  arg8 = (struct FunctionTrain **)(argp8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "c3vaxpy_arr" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = (double)(val9);
  c3vaxpy_arr(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3dot",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3dot" "', argument " "1"" of type '" "struct FunctionTrain *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3dot" "', argument " "2"" of type '" "struct FunctionTrain *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  result = (double)c3dot(arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3gemv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  size_t arg2 ;
  struct FT1DArray *arg3 = (struct FT1DArray *) 0 ;
  size_t arg4 ;
  struct FunctionTrain *arg5 = (struct FunctionTrain *) 0 ;
  double arg6 ;
  struct FunctionTrain *arg7 = (struct FunctionTrain *) 0 ;
  double arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:c3gemv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3gemv" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3gemv" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3gemv" "', argument " "3"" of type '" "struct FT1DArray *""'"); 
  }
  arg3 = (struct FT1DArray *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "c3gemv" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "c3gemv" "', argument " "5"" of type '" "struct FunctionTrain *""'"); 
  }
  arg5 = (struct FunctionTrain *)(argp5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "c3gemv" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = (double)(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "c3gemv" "', argument " "7"" of type '" "struct FunctionTrain *""'"); 
  }
  arg7 = (struct FunctionTrain *)(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "c3gemv" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = (double)(val8);
  c3gemv(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3vaxpy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double arg2 ;
  struct FT1DArray *arg3 = (struct FT1DArray *) 0 ;
  size_t arg4 ;
  struct FT1DArray **arg5 = (struct FT1DArray **) 0 ;
  size_t arg6 ;
  double arg7 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:c3vaxpy",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3vaxpy" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3vaxpy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3vaxpy" "', argument " "3"" of type '" "struct FT1DArray *""'"); 
  }
  arg3 = (struct FT1DArray *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "c3vaxpy" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "c3vaxpy" "', argument " "5"" of type '" "struct FT1DArray **""'"); 
  }
  arg5 = (struct FT1DArray **)(argp5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "c3vaxpy" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "c3vaxpy" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = (double)(val7);
  c3vaxpy(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3vprodsum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double arg2 ;
  struct FT1DArray *arg3 = (struct FT1DArray *) 0 ;
  size_t arg4 ;
  struct FT1DArray *arg5 = (struct FT1DArray *) 0 ;
  size_t arg6 ;
  double arg7 ;
  struct FunctionTrain **arg8 = (struct FunctionTrain **) 0 ;
  double arg9 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:c3vprodsum",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3vprodsum" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3vprodsum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3vprodsum" "', argument " "3"" of type '" "struct FT1DArray *""'"); 
  }
  arg3 = (struct FT1DArray *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "c3vprodsum" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "c3vprodsum" "', argument " "5"" of type '" "struct FT1DArray *""'"); 
  }
  arg5 = (struct FT1DArray *)(argp5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "c3vprodsum" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "c3vprodsum" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = (double)(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "c3vprodsum" "', argument " "8"" of type '" "struct FunctionTrain **""'"); 
  }
  arg8 = (struct FunctionTrain **)(argp8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "c3vprodsum" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = (double)(val9);
  c3vprodsum(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3vgemv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  double arg3 ;
  struct FT1DArray *arg4 = (struct FT1DArray *) 0 ;
  size_t arg5 ;
  struct FT1DArray *arg6 = (struct FT1DArray *) 0 ;
  size_t arg7 ;
  double arg8 ;
  struct FT1DArray **arg9 = (struct FT1DArray **) 0 ;
  size_t arg10 ;
  double arg11 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  size_t val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:c3vgemv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3vgemv" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3vgemv" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c3vgemv" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "c3vgemv" "', argument " "4"" of type '" "struct FT1DArray *""'"); 
  }
  arg4 = (struct FT1DArray *)(argp4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "c3vgemv" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "c3vgemv" "', argument " "6"" of type '" "struct FT1DArray *""'"); 
  }
  arg6 = (struct FT1DArray *)(argp6);
  ecode7 = SWIG_AsVal_size_t(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "c3vgemv" "', argument " "7"" of type '" "size_t""'");
  } 
  arg7 = (size_t)(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "c3vgemv" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = (double)(val8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "c3vgemv" "', argument " "9"" of type '" "struct FT1DArray **""'"); 
  }
  arg9 = (struct FT1DArray **)(argp9);
  ecode10 = SWIG_AsVal_size_t(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "c3vgemv" "', argument " "10"" of type '" "size_t""'");
  } 
  arg10 = (size_t)(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "c3vgemv" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = (double)(val11);
  c3vgemv(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3vgemv_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  double arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  struct FT1DArray *arg7 = (struct FT1DArray *) 0 ;
  size_t arg8 ;
  double arg9 ;
  struct FT1DArray **arg10 = (struct FT1DArray **) 0 ;
  size_t arg11 ;
  double arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  size_t val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:c3vgemv_arr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3vgemv_arr" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3vgemv_arr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c3vgemv_arr" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "c3vgemv_arr" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "c3vgemv_arr" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "c3vgemv_arr" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "c3vgemv_arr" "', argument " "7"" of type '" "struct FT1DArray *""'"); 
  }
  arg7 = (struct FT1DArray *)(argp7);
  ecode8 = SWIG_AsVal_size_t(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "c3vgemv_arr" "', argument " "8"" of type '" "size_t""'");
  } 
  arg8 = (size_t)(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "c3vgemv_arr" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = (double)(val9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_p_FT1DArray, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "c3vgemv_arr" "', argument " "10"" of type '" "struct FT1DArray **""'"); 
  }
  arg10 = (struct FT1DArray **)(argp10);
  ecode11 = SWIG_AsVal_size_t(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "c3vgemv_arr" "', argument " "11"" of type '" "size_t""'");
  } 
  arg11 = (size_t)(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "c3vgemv_arr" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = (double)(val12);
  c3vgemv_arr(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CrossIndex_d_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CrossIndex_d_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrossIndex_d_set" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CrossIndex_d_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->d = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CrossIndex_d_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CrossIndex_d_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrossIndex_d_get" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  result = (size_t) ((arg1)->d);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CrossIndex_n_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CrossIndex_n_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrossIndex_n_set" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CrossIndex_n_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->n = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CrossIndex_n_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CrossIndex_n_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrossIndex_n_get" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  result = (size_t) ((arg1)->n);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CrossIndex_nodes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  struct CrossNode *arg2 = (struct CrossNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CrossIndex_nodes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrossIndex_nodes_set" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CrossNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CrossIndex_nodes_set" "', argument " "2"" of type '" "struct CrossNode *""'"); 
  }
  arg2 = (struct CrossNode *)(argp2);
  if (arg1) (arg1)->nodes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CrossIndex_nodes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct CrossNode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CrossIndex_nodes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrossIndex_nodes_get" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  result = (struct CrossNode *) ((arg1)->nodes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CrossNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CrossIndex")) SWIG_fail;
  result = (struct CrossIndex *)calloc(1, sizeof(struct CrossIndex));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CrossIndex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CrossIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CrossIndex",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CrossIndex" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_cross_index_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct CrossIndex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:cross_index_alloc",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cross_index_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct CrossIndex *)cross_index_alloc(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CrossIndex, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_index_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:cross_index_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cross_index_free" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  cross_index_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_index_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct CrossIndex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:cross_index_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cross_index_copy" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  result = (struct CrossIndex *)cross_index_copy(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CrossIndex, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_index_add_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  size_t arg2 ;
  void *arg3 = (void *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:cross_index_add_index",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cross_index_add_index" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cross_index_add_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cross_index_add_index" "', argument " "3"" of type '" "void *""'"); 
  }
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cross_index_add_index" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  cross_index_add_index(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_index_add_nested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  int arg2 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  size_t arg5 ;
  void *arg6 = (void *) 0 ;
  size_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int res6 ;
  size_t val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:cross_index_add_nested",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cross_index_add_nested" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cross_index_add_nested" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cross_index_add_nested" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cross_index_add_nested" "', argument " "4"" of type '" "void *""'"); 
  }
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cross_index_add_nested" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cross_index_add_nested" "', argument " "6"" of type '" "void *""'"); 
  }
  ecode7 = SWIG_AsVal_size_t(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cross_index_add_nested" "', argument " "7"" of type '" "size_t""'");
  } 
  arg7 = (size_t)(val7);
  cross_index_add_nested(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_index_get_node_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  size_t arg2 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  void *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:cross_index_get_node_value",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cross_index_get_node_value" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cross_index_get_node_value" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cross_index_get_node_value" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (void *)cross_index_get_node_value(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_index_create_nested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  void *arg5 = (void *) 0 ;
  struct CrossIndex *arg6 = (struct CrossIndex *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  int res5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  struct CrossIndex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cross_index_create_nested",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cross_index_create_nested" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cross_index_create_nested" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cross_index_create_nested" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cross_index_create_nested" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4,SWIG_as_voidptrptr(&arg5), 0, 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cross_index_create_nested" "', argument " "5"" of type '" "void *""'"); 
  }
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cross_index_create_nested" "', argument " "6"" of type '" "struct CrossIndex *""'"); 
  }
  arg6 = (struct CrossIndex *)(argp6);
  result = (struct CrossIndex *)cross_index_create_nested(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CrossIndex, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_index_create_nested_ind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  size_t arg2 ;
  size_t *arg3 = (size_t *) 0 ;
  void *arg4 = (void *) 0 ;
  struct CrossIndex *arg5 = (struct CrossIndex *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  struct CrossIndex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:cross_index_create_nested_ind",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cross_index_create_nested_ind" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cross_index_create_nested_ind" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cross_index_create_nested_ind" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cross_index_create_nested_ind" "', argument " "4"" of type '" "void *""'"); 
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cross_index_create_nested_ind" "', argument " "5"" of type '" "struct CrossIndex *""'"); 
  }
  arg5 = (struct CrossIndex *)(argp5);
  result = (struct CrossIndex *)cross_index_create_nested_ind(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CrossIndex, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_index_merge_wspace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  struct CrossIndex *arg2 = (struct CrossIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:cross_index_merge_wspace",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cross_index_merge_wspace" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cross_index_merge_wspace" "', argument " "2"" of type '" "struct CrossIndex *""'"); 
  }
  arg2 = (struct CrossIndex *)(argp2);
  result = (double **)cross_index_merge_wspace(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_index_merge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  struct CrossIndex *arg2 = (struct CrossIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:cross_index_merge",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cross_index_merge" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cross_index_merge" "', argument " "2"" of type '" "struct CrossIndex *""'"); 
  }
  arg2 = (struct CrossIndex *)(argp2);
  result = (double **)cross_index_merge(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_index_array_initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct CrossIndex **arg2 = (struct CrossIndex **) 0 ;
  int arg3 ;
  int arg4 ;
  size_t *arg5 = (size_t *) 0 ;
  void **arg6 = (void **) 0 ;
  size_t arg7 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:cross_index_array_initialize",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cross_index_array_initialize" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cross_index_array_initialize" "', argument " "2"" of type '" "struct CrossIndex **""'"); 
  }
  arg2 = (struct CrossIndex **)(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cross_index_array_initialize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cross_index_array_initialize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cross_index_array_initialize" "', argument " "5"" of type '" "size_t *""'"); 
  }
  arg5 = (size_t *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_p_void, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cross_index_array_initialize" "', argument " "6"" of type '" "void **""'"); 
  }
  arg6 = (void **)(argp6);
  ecode7 = SWIG_AsVal_size_t(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cross_index_array_initialize" "', argument " "7"" of type '" "size_t""'");
  } 
  arg7 = (size_t)(val7);
  cross_index_array_initialize(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross_index_copylast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:cross_index_copylast",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cross_index_copylast" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cross_index_copylast" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  cross_index_copylast(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_cross_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct CrossIndex *arg1 = (struct CrossIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:print_cross_index",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CrossIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_cross_index" "', argument " "1"" of type '" "struct CrossIndex *""'"); 
  }
  arg1 = (struct CrossIndex *)(argp1);
  print_cross_index(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Qmarray_nrows_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Qmarray_nrows_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Qmarray_nrows_set" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Qmarray_nrows_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->nrows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Qmarray_nrows_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Qmarray_nrows_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Qmarray_nrows_get" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  result = (size_t) ((arg1)->nrows);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Qmarray_ncols_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Qmarray_ncols_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Qmarray_ncols_set" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Qmarray_ncols_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->ncols = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Qmarray_ncols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Qmarray_ncols_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Qmarray_ncols_get" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  result = (size_t) ((arg1)->ncols);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Qmarray_funcs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct GenericFunction **arg2 = (struct GenericFunction **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Qmarray_funcs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Qmarray_funcs_set" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Qmarray_funcs_set" "', argument " "2"" of type '" "struct GenericFunction **""'"); 
  }
  arg2 = (struct GenericFunction **)(argp2);
  if (arg1) (arg1)->funcs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Qmarray_funcs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct GenericFunction **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Qmarray_funcs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Qmarray_funcs_get" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  result = (struct GenericFunction **) ((arg1)->funcs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Qmarray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Qmarray")) SWIG_fail;
  result = (struct Qmarray *)calloc(1, sizeof(struct Qmarray));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Qmarray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Qmarray",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Qmarray" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_qmarray_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_alloc",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "qmarray_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_alloc" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (struct Qmarray *)qmarray_alloc(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_free" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  qmarray_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_copy" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  result = (struct Qmarray *)qmarray_copy((struct Qmarray const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_operate_elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Operator *arg2 = (struct Operator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_operate_elements",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_operate_elements" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Operator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_operate_elements" "', argument " "2"" of type '" "struct Operator const *""'"); 
  }
  arg2 = (struct Operator *)(argp2);
  result = (struct Qmarray *)qmarray_operate_elements((struct Qmarray const *)arg1,(struct Operator const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_serialize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_serialize" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_serialize" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_serialize" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (unsigned char *)qmarray_serialize(arg1,(struct Qmarray const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_deserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct Qmarray **arg2 = (struct Qmarray **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_deserialize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_deserialize" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_deserialize" "', argument " "2"" of type '" "struct Qmarray **""'"); 
  }
  arg2 = (struct Qmarray **)(argp2);
  result = (unsigned char *)qmarray_deserialize(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_savetxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_savetxt",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_savetxt" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_savetxt" "', argument " "2"" of type '" "FILE *""'"); 
  }
  arg2 = (FILE *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qmarray_savetxt" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  qmarray_savetxt((struct Qmarray const *)arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_loadtxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FILE *arg1 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_loadtxt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_loadtxt" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = (FILE *)(argp1);
  result = (struct Qmarray *)qmarray_loadtxt(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_approx1d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct OneApproxOpts *arg3 = (struct OneApproxOpts *) 0 ;
  struct Fwrap *arg4 = (struct Fwrap *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:qmarray_approx1d",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "qmarray_approx1d" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_approx1d" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_approx1d" "', argument " "3"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg3 = (struct OneApproxOpts *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qmarray_approx1d" "', argument " "4"" of type '" "struct Fwrap *""'"); 
  }
  arg4 = (struct Fwrap *)(argp4);
  result = (struct Qmarray *)qmarray_approx1d(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_orth1d_rows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct OneApproxOpts *arg3 = (struct OneApproxOpts *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_orth1d_rows",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "qmarray_orth1d_rows" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_orth1d_rows" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_orth1d_rows" "', argument " "3"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg3 = (struct OneApproxOpts *)(argp3);
  result = (struct Qmarray *)qmarray_orth1d_rows(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_orth1d_columns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct OneApproxOpts *arg3 = (struct OneApproxOpts *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_orth1d_columns",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "qmarray_orth1d_columns" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_orth1d_columns" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_orth1d_columns" "', argument " "3"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg3 = (struct OneApproxOpts *)(argp3);
  result = (struct Qmarray *)qmarray_orth1d_columns(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct OneApproxOpts *arg3 = (struct OneApproxOpts *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_zeros",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "qmarray_zeros" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_zeros" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_zeros" "', argument " "3"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg3 = (struct OneApproxOpts *)(argp3);
  result = (struct Qmarray *)qmarray_zeros(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_poly_randu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum poly_type arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  double arg5 ;
  double arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:qmarray_poly_randu",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "qmarray_poly_randu" "', argument " "1"" of type '" "enum poly_type""'");
  } 
  arg1 = (enum poly_type)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_poly_randu" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qmarray_poly_randu" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "qmarray_poly_randu" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "qmarray_poly_randu" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "qmarray_poly_randu" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = (double)(val6);
  result = (struct Qmarray *)qmarray_poly_randu(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_get_func_base(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  void *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_get_func_base",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_get_func_base" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_get_func_base" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qmarray_get_func_base" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  result = (void *)qmarray_get_func_base((struct Qmarray const *)arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_get_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_get_func",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_get_func" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_get_func" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qmarray_get_func" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  result = (struct GenericFunction *)qmarray_get_func((struct Qmarray const *)arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_set_row(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  struct Quasimatrix *arg3 = (struct Quasimatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_set_row",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_set_row" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_set_row" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_set_row" "', argument " "3"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg3 = (struct Quasimatrix *)(argp3);
  qmarray_set_row(arg1,arg2,(struct Quasimatrix const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_extract_row(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Quasimatrix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_extract_row",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_extract_row" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_extract_row" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (struct Quasimatrix *)qmarray_extract_row((struct Qmarray const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Quasimatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_set_column(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  struct Quasimatrix *arg3 = (struct Quasimatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_set_column",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_set_column" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_set_column" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_set_column" "', argument " "3"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg3 = (struct Quasimatrix *)(argp3);
  qmarray_set_column(arg1,arg2,(struct Quasimatrix const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_set_column_gf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  struct GenericFunction **arg3 = (struct GenericFunction **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_set_column_gf",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_set_column_gf" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_set_column_gf" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_set_column_gf" "', argument " "3"" of type '" "struct GenericFunction **""'"); 
  }
  arg3 = (struct GenericFunction **)(argp3);
  qmarray_set_column_gf(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_extract_column(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Quasimatrix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_extract_column",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_extract_column" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_extract_column" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (struct Quasimatrix *)qmarray_extract_column((struct Qmarray const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Quasimatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_get_ncols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_get_ncols",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_get_ncols" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  result = (size_t)qmarray_get_ncols((struct Qmarray const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_get_nrows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_get_nrows",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_get_nrows" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  result = (size_t)qmarray_get_nrows((struct Qmarray const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  double *arg2 = (double *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmam",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmam" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmam" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qmam" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  result = (struct Qmarray *)qmam((struct Qmarray const *)arg1,(double const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmatm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  double *arg2 = (double *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmatm",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmatm" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmatm" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qmatm" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  result = (struct Qmarray *)qmatm((struct Qmarray const *)arg1,(double const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mqma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:mqma",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mqma" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = (double *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mqma" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mqma" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  result = (struct Qmarray *)mqma((double const *)arg1,(struct Qmarray const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmaqma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmaqma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmaqma" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmaqma" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (struct Qmarray *)qmaqma((struct Qmarray const *)arg1,(struct Qmarray const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmatqma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmatqma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmatqma" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmatqma" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (struct Qmarray *)qmatqma((struct Qmarray const *)arg1,(struct Qmarray const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmaqmat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmaqmat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmaqmat" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmaqmat" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (struct Qmarray *)qmaqmat((struct Qmarray const *)arg1,(struct Qmarray const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmatqmat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmatqmat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmatqmat" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmatqmat" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (struct Qmarray *)qmatqmat((struct Qmarray const *)arg1,(struct Qmarray const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmatqma_integrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmatqma_integrate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmatqma_integrate" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmatqma_integrate" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (double *)qmatqma_integrate((struct Qmarray const *)arg1,(struct Qmarray const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmaqmat_integrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmaqmat_integrate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmaqmat_integrate" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmaqmat_integrate" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (double *)qmaqmat_integrate((struct Qmarray const *)arg1,(struct Qmarray const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmatqmat_integrate_weighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmatqmat_integrate_weighted",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmatqmat_integrate_weighted" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmatqmat_integrate_weighted" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (double *)qmatqmat_integrate_weighted((struct Qmarray const *)arg1,(struct Qmarray const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmatqmat_integrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmatqmat_integrate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmatqmat_integrate" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmatqmat_integrate" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (double *)qmatqmat_integrate((struct Qmarray const *)arg1,(struct Qmarray const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_kron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_kron",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_kron" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_kron" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (struct Qmarray *)qmarray_kron((struct Qmarray const *)arg1,(struct Qmarray const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_kron_integrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_kron_integrate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_kron_integrate" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_kron_integrate" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (double *)qmarray_kron_integrate((struct Qmarray const *)arg1,(struct Qmarray const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_kron_integrate_weighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_kron_integrate_weighted",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_kron_integrate_weighted" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_kron_integrate_weighted" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (double *)qmarray_kron_integrate_weighted((struct Qmarray const *)arg1,(struct Qmarray const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_vec_kron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  struct Qmarray *arg3 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_vec_kron",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_vec_kron" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = (double *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_vec_kron" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_vec_kron" "', argument " "3"" of type '" "struct Qmarray const *""'"); 
  }
  arg3 = (struct Qmarray *)(argp3);
  result = (struct Qmarray *)qmarray_vec_kron((double const *)arg1,(struct Qmarray const *)arg2,(struct Qmarray const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_vec_kron_integrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  struct Qmarray *arg3 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_vec_kron_integrate",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_vec_kron_integrate" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = (double *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_vec_kron_integrate" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_vec_kron_integrate" "', argument " "3"" of type '" "struct Qmarray const *""'"); 
  }
  arg3 = (struct Qmarray *)(argp3);
  result = (double *)qmarray_vec_kron_integrate((double const *)arg1,(struct Qmarray const *)arg2,(struct Qmarray const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_vec_kron_integrate_weighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  struct Qmarray *arg3 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_vec_kron_integrate_weighted",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_vec_kron_integrate_weighted" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = (double *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_vec_kron_integrate_weighted" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_vec_kron_integrate_weighted" "', argument " "3"" of type '" "struct Qmarray const *""'"); 
  }
  arg3 = (struct Qmarray *)(argp3);
  result = (double *)qmarray_vec_kron_integrate_weighted((double const *)arg1,(struct Qmarray const *)arg2,(struct Qmarray const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_mat_kron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  struct Qmarray *arg3 = (struct Qmarray *) 0 ;
  struct Qmarray *arg4 = (struct Qmarray *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:qmarray_mat_kron",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "qmarray_mat_kron" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_mat_kron" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_mat_kron" "', argument " "3"" of type '" "struct Qmarray const *""'"); 
  }
  arg3 = (struct Qmarray *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qmarray_mat_kron" "', argument " "4"" of type '" "struct Qmarray const *""'"); 
  }
  arg4 = (struct Qmarray *)(argp4);
  result = (struct Qmarray *)qmarray_mat_kron(arg1,(double const *)arg2,(struct Qmarray const *)arg3,(struct Qmarray const *)arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_kron_mat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  struct Qmarray *arg3 = (struct Qmarray *) 0 ;
  struct Qmarray *arg4 = (struct Qmarray *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:qmarray_kron_mat",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "qmarray_kron_mat" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_kron_mat" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_kron_mat" "', argument " "3"" of type '" "struct Qmarray const *""'"); 
  }
  arg3 = (struct Qmarray *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qmarray_kron_mat" "', argument " "4"" of type '" "struct Qmarray const *""'"); 
  }
  arg4 = (struct Qmarray *)(argp4);
  result = (struct Qmarray *)qmarray_kron_mat(arg1,(double const *)arg2,(struct Qmarray const *)arg3,(struct Qmarray const *)arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_block_kron_mat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char arg1 ;
  int arg2 ;
  size_t arg3 ;
  struct Qmarray **arg4 = (struct Qmarray **) 0 ;
  struct Qmarray *arg5 = (struct Qmarray *) 0 ;
  size_t arg6 ;
  double *arg7 = (double *) 0 ;
  struct Qmarray *arg8 = (struct Qmarray *) 0 ;
  char val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:qmarray_block_kron_mat",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_char(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "qmarray_block_kron_mat" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = (char)(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_block_kron_mat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qmarray_block_kron_mat" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qmarray_block_kron_mat" "', argument " "4"" of type '" "struct Qmarray **""'"); 
  }
  arg4 = (struct Qmarray **)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "qmarray_block_kron_mat" "', argument " "5"" of type '" "struct Qmarray *""'"); 
  }
  arg5 = (struct Qmarray *)(argp5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "qmarray_block_kron_mat" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "qmarray_block_kron_mat" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "qmarray_block_kron_mat" "', argument " "8"" of type '" "struct Qmarray *""'"); 
  }
  arg8 = (struct Qmarray *)(argp8);
  qmarray_block_kron_mat(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_integrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_integrate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_integrate" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  result = (double *)qmarray_integrate((struct Qmarray const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_integrate_weighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_integrate_weighted",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_integrate_weighted" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  result = (double *)qmarray_integrate_weighted((struct Qmarray const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_norm2diff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_norm2diff",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_norm2diff" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_norm2diff" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (double)qmarray_norm2diff((struct Qmarray const *)arg1,(struct Qmarray const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_norm2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_norm2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_norm2" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  result = (double)qmarray_norm2((struct Qmarray const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_axpy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  struct Qmarray *arg3 = (struct Qmarray *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_axpy",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "qmarray_axpy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_axpy" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_axpy" "', argument " "3"" of type '" "struct Qmarray *""'"); 
  }
  arg3 = (struct Qmarray *)(argp3);
  qmarray_axpy(arg1,(struct Qmarray const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_lu1d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t *arg4 = (size_t *) 0 ;
  double *arg5 = (double *) 0 ;
  struct OneApproxOpts *arg6 = (struct OneApproxOpts *) 0 ;
  void *arg7 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:qmarray_lu1d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_lu1d" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_lu1d" "', argument " "2"" of type '" "struct Qmarray *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_lu1d" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qmarray_lu1d" "', argument " "4"" of type '" "size_t *""'"); 
  }
  arg4 = (size_t *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "qmarray_lu1d" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "qmarray_lu1d" "', argument " "6"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg6 = (struct OneApproxOpts *)(argp6);
  res7 = SWIG_ConvertPtr(obj6,SWIG_as_voidptrptr(&arg7), 0, 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "qmarray_lu1d" "', argument " "7"" of type '" "void *""'"); 
  }
  result = (int)qmarray_lu1d(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_maxvol1d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  double *arg2 = (double *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  double *arg4 = (double *) 0 ;
  struct OneApproxOpts *arg5 = (struct OneApproxOpts *) 0 ;
  void *arg6 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:qmarray_maxvol1d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_maxvol1d" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_maxvol1d" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_maxvol1d" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qmarray_maxvol1d" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "qmarray_maxvol1d" "', argument " "5"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg5 = (struct OneApproxOpts *)(argp5);
  res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "qmarray_maxvol1d" "', argument " "6"" of type '" "void *""'"); 
  }
  result = (int)qmarray_maxvol1d(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_qhouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_qhouse",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_qhouse" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_qhouse" "', argument " "2"" of type '" "struct Qmarray *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (int)qmarray_qhouse(arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_qhouse_rows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_qhouse_rows",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_qhouse_rows" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_qhouse_rows" "', argument " "2"" of type '" "struct Qmarray *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (int)qmarray_qhouse_rows(arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_householder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  struct Qmarray *arg3 = (struct Qmarray *) 0 ;
  double *arg4 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:qmarray_householder",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_householder" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_householder" "', argument " "2"" of type '" "struct Qmarray *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_householder" "', argument " "3"" of type '" "struct Qmarray *""'"); 
  }
  arg3 = (struct Qmarray *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qmarray_householder" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (int)qmarray_householder(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_householder_rows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  struct Qmarray *arg3 = (struct Qmarray *) 0 ;
  double *arg4 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:qmarray_householder_rows",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_householder_rows" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_householder_rows" "', argument " "2"" of type '" "struct Qmarray *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_householder_rows" "', argument " "3"" of type '" "struct Qmarray *""'"); 
  }
  arg3 = (struct Qmarray *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qmarray_householder_rows" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (int)qmarray_householder_rows(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_householder_simple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  double *arg3 = (double *) 0 ;
  struct OneApproxOpts *arg4 = (struct OneApproxOpts *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:qmarray_householder_simple",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_householder_simple" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_householder_simple" "', argument " "2"" of type '" "struct Qmarray *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_householder_simple" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qmarray_householder_simple" "', argument " "4"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg4 = (struct OneApproxOpts *)(argp4);
  result = (struct Qmarray *)qmarray_householder_simple(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_svd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray **arg2 = (struct Qmarray **) 0 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  struct OneApproxOpts *arg5 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:qmarray_svd",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_svd" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_svd" "', argument " "2"" of type '" "struct Qmarray **""'"); 
  }
  arg2 = (struct Qmarray **)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_svd" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qmarray_svd" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "qmarray_svd" "', argument " "5"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg5 = (struct OneApproxOpts *)(argp5);
  result = (int)qmarray_svd(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_truncated_svd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray **arg2 = (struct Qmarray **) 0 ;
  double **arg3 = (double **) 0 ;
  double **arg4 = (double **) 0 ;
  double arg5 ;
  struct OneApproxOpts *arg6 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:qmarray_truncated_svd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_truncated_svd" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_truncated_svd" "', argument " "2"" of type '" "struct Qmarray **""'"); 
  }
  arg2 = (struct Qmarray **)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_truncated_svd" "', argument " "3"" of type '" "double **""'"); 
  }
  arg3 = (double **)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qmarray_truncated_svd" "', argument " "4"" of type '" "double **""'"); 
  }
  arg4 = (double **)(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "qmarray_truncated_svd" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "qmarray_truncated_svd" "', argument " "6"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg6 = (struct OneApproxOpts *)(argp6);
  result = (size_t)qmarray_truncated_svd(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_absmax1d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  double *arg2 = (double *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  size_t *arg4 = (size_t *) 0 ;
  double *arg5 = (double *) 0 ;
  void *arg6 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:qmarray_absmax1d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_absmax1d" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_absmax1d" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_absmax1d" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qmarray_absmax1d" "', argument " "4"" of type '" "size_t *""'"); 
  }
  arg4 = (size_t *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "qmarray_absmax1d" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "qmarray_absmax1d" "', argument " "6"" of type '" "void *""'"); 
  }
  qmarray_absmax1d(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_transpose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_transpose",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_transpose" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  result = (struct Qmarray *)qmarray_transpose(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_stackh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_stackh",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_stackh" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_stackh" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (struct Qmarray *)qmarray_stackh((struct Qmarray const *)arg1,(struct Qmarray const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_stackv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_stackv",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_stackv" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_stackv" "', argument " "2"" of type '" "struct Qmarray const *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (struct Qmarray *)qmarray_stackv((struct Qmarray const *)arg1,(struct Qmarray const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_blockdiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray *arg2 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_blockdiag",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_blockdiag" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_blockdiag" "', argument " "2"" of type '" "struct Qmarray *""'"); 
  }
  arg2 = (struct Qmarray *)(argp2);
  result = (struct Qmarray *)qmarray_blockdiag(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_deriv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_deriv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_deriv" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  result = (struct Qmarray *)qmarray_deriv(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_dderiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_dderiv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_dderiv" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  result = (struct Qmarray *)qmarray_dderiv(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_dderiv_periodic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_dderiv_periodic",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_dderiv_periodic" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  result = (struct Qmarray *)qmarray_dderiv_periodic(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_deriv_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  double arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_deriv_eval",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_deriv_eval" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_deriv_eval" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_deriv_eval" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  qmarray_deriv_eval((struct Qmarray const *)arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_roundt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray **arg1 = (struct Qmarray **) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_roundt",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_roundt" "', argument " "1"" of type '" "struct Qmarray **""'"); 
  }
  arg1 = (struct Qmarray **)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_roundt" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  qmarray_roundt(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  double arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_eval",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_eval" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_eval" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_eval" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  qmarray_eval(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_func_get_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_func_get_nparams",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_func_get_nparams" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_func_get_nparams" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qmarray_func_get_nparams" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  result = (size_t)qmarray_func_get_nparams((struct Qmarray const *)arg1,arg2,arg3);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_get_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_get_nparams",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_get_nparams" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_get_nparams" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (size_t)qmarray_get_nparams((struct Qmarray const *)arg1,arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_get_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_get_params",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_get_params" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_get_params" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (size_t)qmarray_get_params(arg1,arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_uni_update_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:qmarray_uni_update_params",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_uni_update_params" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_uni_update_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qmarray_uni_update_params" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "qmarray_uni_update_params" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "qmarray_uni_update_params" "', argument " "5"" of type '" "double const *""'"); 
  }
  arg5 = (double *)(argp5);
  qmarray_uni_update_params(arg1,arg2,arg3,arg4,(double const *)arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_update_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_update_params",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_update_params" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_update_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_update_params" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  qmarray_update_params(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_param_grad_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  double *arg7 = (double *) 0 ;
  size_t arg8 ;
  double *arg9 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:qmarray_param_grad_eval",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_param_grad_eval" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_param_grad_eval" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_param_grad_eval" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "qmarray_param_grad_eval" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "qmarray_param_grad_eval" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "qmarray_param_grad_eval" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "qmarray_param_grad_eval" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  ecode8 = SWIG_AsVal_size_t(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "qmarray_param_grad_eval" "', argument " "8"" of type '" "size_t""'");
  } 
  arg8 = (size_t)(val8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "qmarray_param_grad_eval" "', argument " "9"" of type '" "double *""'"); 
  }
  arg9 = (double *)(argp9);
  qmarray_param_grad_eval(arg1,arg2,(double const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_linparam_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:qmarray_linparam_eval",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_linparam_eval" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_linparam_eval" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_linparam_eval" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "qmarray_linparam_eval" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "qmarray_linparam_eval" "', argument " "5"" of type '" "double const *""'"); 
  }
  arg5 = (double *)(argp5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "qmarray_linparam_eval" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  qmarray_linparam_eval(arg1,arg2,arg3,arg4,(double const *)arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_param_grad_eval_sparse_mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  double *arg7 = (double *) 0 ;
  size_t arg8 ;
  double *arg9 = (double *) 0 ;
  double *arg10 = (double *) 0 ;
  size_t arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  size_t val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:qmarray_param_grad_eval_sparse_mult",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_param_grad_eval_sparse_mult" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_param_grad_eval_sparse_mult" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_param_grad_eval_sparse_mult" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "qmarray_param_grad_eval_sparse_mult" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "qmarray_param_grad_eval_sparse_mult" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "qmarray_param_grad_eval_sparse_mult" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "qmarray_param_grad_eval_sparse_mult" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  ecode8 = SWIG_AsVal_size_t(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "qmarray_param_grad_eval_sparse_mult" "', argument " "8"" of type '" "size_t""'");
  } 
  arg8 = (size_t)(val8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "qmarray_param_grad_eval_sparse_mult" "', argument " "9"" of type '" "double *""'"); 
  }
  arg9 = (double *)(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "qmarray_param_grad_eval_sparse_mult" "', argument " "10"" of type '" "double *""'"); 
  }
  arg10 = (double *)(argp10);
  ecode11 = SWIG_AsVal_size_t(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "qmarray_param_grad_eval_sparse_mult" "', argument " "11"" of type '" "size_t""'");
  } 
  arg11 = (size_t)(val11);
  qmarray_param_grad_eval_sparse_mult(arg1,arg2,(double const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_param_grad_sqnorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  double arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_param_grad_sqnorm",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_param_grad_sqnorm" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_param_grad_sqnorm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_param_grad_sqnorm" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (double)qmarray_param_grad_sqnorm(arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_create_nodal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct Qmarray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmarray_create_nodal",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_create_nodal" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_create_nodal" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_create_nodal" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (struct Qmarray *)qmarray_create_nodal(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Qmarray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_is_kristoffel_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_is_kristoffel_active",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_is_kristoffel_active" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  result = (int)qmarray_is_kristoffel_active((struct Qmarray const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_activate_kristoffel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_activate_kristoffel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_activate_kristoffel" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  qmarray_activate_kristoffel(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_deactivate_kristoffel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:qmarray_deactivate_kristoffel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_deactivate_kristoffel" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  qmarray_deactivate_kristoffel(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_get_kristoffel_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_get_kristoffel_weight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_get_kristoffel_weight" "', argument " "1"" of type '" "struct Qmarray const *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qmarray_get_kristoffel_weight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)qmarray_get_kristoffel_weight((struct Qmarray const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_qr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray **arg2 = (struct Qmarray **) 0 ;
  double **arg3 = (double **) 0 ;
  struct OneApproxOpts *arg4 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:qmarray_qr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_qr" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_qr" "', argument " "2"" of type '" "struct Qmarray **""'"); 
  }
  arg2 = (struct Qmarray **)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_qr" "', argument " "3"" of type '" "double **""'"); 
  }
  arg3 = (double **)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qmarray_qr" "', argument " "4"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg4 = (struct OneApproxOpts *)(argp4);
  result = (int)qmarray_qr(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_lq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  struct Qmarray **arg2 = (struct Qmarray **) 0 ;
  double **arg3 = (double **) 0 ;
  struct OneApproxOpts *arg4 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:qmarray_lq",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_lq" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_lq" "', argument " "2"" of type '" "struct Qmarray **""'"); 
  }
  arg2 = (struct Qmarray **)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qmarray_lq" "', argument " "3"" of type '" "double **""'"); 
  }
  arg3 = (double **)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qmarray_lq" "', argument " "4"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg4 = (struct OneApproxOpts *)(argp4);
  result = (int)qmarray_lq(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_qr_gs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  double **arg2 = (double **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_qr_gs",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_qr_gs" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_qr_gs" "', argument " "2"" of type '" "double **""'"); 
  }
  arg2 = (double **)(argp2);
  result = (int)qmarray_qr_gs(arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmarray_lq_gs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  double **arg2 = (double **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmarray_lq_gs",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmarray_lq_gs" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmarray_lq_gs" "', argument " "2"" of type '" "double **""'"); 
  }
  arg2 = (double **)(argp2);
  result = (int)qmarray_lq_gs(arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_qmarray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Qmarray *arg1 = (struct Qmarray *) 0 ;
  size_t arg2 ;
  void *arg3 = (void *) 0 ;
  FILE *arg4 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:print_qmarray",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Qmarray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_qmarray" "', argument " "1"" of type '" "struct Qmarray *""'"); 
  }
  arg1 = (struct Qmarray *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "print_qmarray" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "print_qmarray" "', argument " "3"" of type '" "void *""'"); 
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "print_qmarray" "', argument " "4"" of type '" "FILE *""'"); 
  }
  arg4 = (FILE *)(argp4);
  print_qmarray(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Quasimatrix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:quasimatrix_alloc",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "quasimatrix_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct Quasimatrix *)quasimatrix_alloc(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Quasimatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_free_funcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:quasimatrix_free_funcs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_free_funcs" "', argument " "1"" of type '" "struct Quasimatrix *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  quasimatrix_free_funcs(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:quasimatrix_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_free" "', argument " "1"" of type '" "struct Quasimatrix *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  quasimatrix_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_get_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:quasimatrix_get_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_get_size" "', argument " "1"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  result = (size_t)quasimatrix_get_size((struct Quasimatrix const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_set_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:quasimatrix_set_size",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_set_size" "', argument " "1"" of type '" "struct Quasimatrix *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "quasimatrix_set_size" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  quasimatrix_set_size(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_get_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:quasimatrix_get_func",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_get_func" "', argument " "1"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "quasimatrix_get_func" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (struct GenericFunction *)quasimatrix_get_func((struct Quasimatrix const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_set_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  struct GenericFunction *arg2 = (struct GenericFunction *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:quasimatrix_set_func",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_set_func" "', argument " "1"" of type '" "struct Quasimatrix *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_set_func" "', argument " "2"" of type '" "struct GenericFunction const *""'"); 
  }
  arg2 = (struct GenericFunction *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "quasimatrix_set_func" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  quasimatrix_set_func(arg1,(struct GenericFunction const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_get_funcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct GenericFunction **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:quasimatrix_get_funcs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_get_funcs" "', argument " "1"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  result = (struct GenericFunction **)quasimatrix_get_funcs((struct Quasimatrix const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_set_funcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  struct GenericFunction **arg2 = (struct GenericFunction **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:quasimatrix_set_funcs",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_set_funcs" "', argument " "1"" of type '" "struct Quasimatrix *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_set_funcs" "', argument " "2"" of type '" "struct GenericFunction **""'"); 
  }
  arg2 = (struct GenericFunction **)(argp2);
  quasimatrix_set_funcs(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_get_funcs_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  struct GenericFunction ***arg2 = (struct GenericFunction ***) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:quasimatrix_get_funcs_ref",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_get_funcs_ref" "', argument " "1"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_get_funcs_ref" "', argument " "2"" of type '" "struct GenericFunction ***""'"); 
  }
  arg2 = (struct GenericFunction ***)(argp2);
  quasimatrix_get_funcs_ref((struct Quasimatrix const *)arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_approx1d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct Fwrap *arg2 = (struct Fwrap *) 0 ;
  enum function_class *arg3 = (enum function_class *) 0 ;
  void *arg4 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct Quasimatrix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:quasimatrix_approx1d",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "quasimatrix_approx1d" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_approx1d" "', argument " "2"" of type '" "struct Fwrap *""'"); 
  }
  arg2 = (struct Fwrap *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_function_class, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "quasimatrix_approx1d" "', argument " "3"" of type '" "enum function_class *""'"); 
  }
  arg3 = (enum function_class *)(argp3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "quasimatrix_approx1d" "', argument " "4"" of type '" "void *""'"); 
  }
  result = (struct Quasimatrix *)quasimatrix_approx1d(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Quasimatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Quasimatrix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:quasimatrix_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_copy" "', argument " "1"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  result = (struct Quasimatrix *)quasimatrix_copy((struct Quasimatrix const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Quasimatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct Quasimatrix *arg2 = (struct Quasimatrix *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:quasimatrix_serialize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_serialize" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_serialize" "', argument " "2"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg2 = (struct Quasimatrix *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "quasimatrix_serialize" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (unsigned char *)quasimatrix_serialize(arg1,(struct Quasimatrix const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_deserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct Quasimatrix **arg2 = (struct Quasimatrix **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:quasimatrix_deserialize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_deserialize" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_deserialize" "', argument " "2"" of type '" "struct Quasimatrix **""'"); 
  }
  arg2 = (struct Quasimatrix **)(argp2);
  result = (unsigned char *)quasimatrix_deserialize(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_orth1d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  enum function_class arg2 ;
  void *arg3 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct Quasimatrix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:quasimatrix_orth1d",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "quasimatrix_orth1d" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "quasimatrix_orth1d" "', argument " "2"" of type '" "enum function_class""'");
  } 
  arg2 = (enum function_class)(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "quasimatrix_orth1d" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (struct Quasimatrix *)quasimatrix_orth1d(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Quasimatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_absmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:quasimatrix_absmax",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_absmax" "', argument " "1"" of type '" "struct Quasimatrix *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_absmax" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "quasimatrix_absmax" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "quasimatrix_absmax" "', argument " "4"" of type '" "void *""'"); 
  }
  result = (size_t)quasimatrix_absmax(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_inner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  struct Quasimatrix *arg2 = (struct Quasimatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:quasimatrix_inner",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_inner" "', argument " "1"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_inner" "', argument " "2"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg2 = (struct Quasimatrix *)(argp2);
  result = (double)quasimatrix_inner((struct Quasimatrix const *)arg1,(struct Quasimatrix const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:qmv",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmv" "', argument " "1"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmv" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (struct GenericFunction *)qmv((struct Quasimatrix const *)arg1,(double const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  double *arg2 = (double *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct Quasimatrix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmm",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmm" "', argument " "1"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmm" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qmm" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  result = (struct Quasimatrix *)qmm((struct Quasimatrix const *)arg1,(double const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Quasimatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qmmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  double *arg2 = (double *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct Quasimatrix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:qmmt",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qmmt" "', argument " "1"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qmmt" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qmmt" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  result = (struct Quasimatrix *)qmmt((struct Quasimatrix const *)arg1,(double const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Quasimatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_daxpby(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct Quasimatrix *arg2 = (struct Quasimatrix *) 0 ;
  double arg3 ;
  struct Quasimatrix *arg4 = (struct Quasimatrix *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct Quasimatrix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:quasimatrix_daxpby",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "quasimatrix_daxpby" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_daxpby" "', argument " "2"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg2 = (struct Quasimatrix *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "quasimatrix_daxpby" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "quasimatrix_daxpby" "', argument " "4"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg4 = (struct Quasimatrix *)(argp4);
  result = (struct Quasimatrix *)quasimatrix_daxpby(arg1,(struct Quasimatrix const *)arg2,arg3,(struct Quasimatrix const *)arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Quasimatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_householder_simple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  double *arg2 = (double *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct Quasimatrix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:quasimatrix_householder_simple",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_householder_simple" "', argument " "1"" of type '" "struct Quasimatrix *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_householder_simple" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "quasimatrix_householder_simple" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (struct Quasimatrix *)quasimatrix_householder_simple(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Quasimatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_householder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  struct Quasimatrix *arg2 = (struct Quasimatrix *) 0 ;
  struct Quasimatrix *arg3 = (struct Quasimatrix *) 0 ;
  double *arg4 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:quasimatrix_householder",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_householder" "', argument " "1"" of type '" "struct Quasimatrix *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_householder" "', argument " "2"" of type '" "struct Quasimatrix *""'"); 
  }
  arg2 = (struct Quasimatrix *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "quasimatrix_householder" "', argument " "3"" of type '" "struct Quasimatrix *""'"); 
  }
  arg3 = (struct Quasimatrix *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "quasimatrix_householder" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (int)quasimatrix_householder(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_qhouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  struct Quasimatrix *arg2 = (struct Quasimatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:quasimatrix_qhouse",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_qhouse" "', argument " "1"" of type '" "struct Quasimatrix *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_qhouse" "', argument " "2"" of type '" "struct Quasimatrix *""'"); 
  }
  arg2 = (struct Quasimatrix *)(argp2);
  result = (int)quasimatrix_qhouse(arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_lu1d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  struct Quasimatrix *arg2 = (struct Quasimatrix *) 0 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  void *arg5 = (void *) 0 ;
  void *arg6 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 ;
  int res6 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:quasimatrix_lu1d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_lu1d" "', argument " "1"" of type '" "struct Quasimatrix *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_lu1d" "', argument " "2"" of type '" "struct Quasimatrix *""'"); 
  }
  arg2 = (struct Quasimatrix *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "quasimatrix_lu1d" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "quasimatrix_lu1d" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4,SWIG_as_voidptrptr(&arg5), 0, 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "quasimatrix_lu1d" "', argument " "5"" of type '" "void *""'"); 
  }
  res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "quasimatrix_lu1d" "', argument " "6"" of type '" "void *""'"); 
  }
  result = (int)quasimatrix_lu1d(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_maxvol1d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  void *arg4 = (void *) 0 ;
  void *arg5 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  int res5 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:quasimatrix_maxvol1d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_maxvol1d" "', argument " "1"" of type '" "struct Quasimatrix *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_maxvol1d" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "quasimatrix_maxvol1d" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "quasimatrix_maxvol1d" "', argument " "4"" of type '" "void *""'"); 
  }
  res5 = SWIG_ConvertPtr(obj4,SWIG_as_voidptrptr(&arg5), 0, 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "quasimatrix_maxvol1d" "', argument " "5"" of type '" "void *""'"); 
  }
  result = (int)quasimatrix_maxvol1d(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_rank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:quasimatrix_rank",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_rank" "', argument " "1"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_rank" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (size_t)quasimatrix_rank((struct Quasimatrix const *)arg1,arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:quasimatrix_norm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_norm" "', argument " "1"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  result = (double)quasimatrix_norm((struct Quasimatrix const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quasimatrix_print(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Quasimatrix *arg1 = (struct Quasimatrix *) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:quasimatrix_print",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Quasimatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quasimatrix_print" "', argument " "1"" of type '" "struct Quasimatrix const *""'"); 
  }
  arg1 = (struct Quasimatrix *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quasimatrix_print" "', argument " "2"" of type '" "FILE *""'"); 
  }
  arg2 = (FILE *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "quasimatrix_print" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "quasimatrix_print" "', argument " "4"" of type '" "void *""'"); 
  }
  quasimatrix_print((struct Quasimatrix const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneApproxOpts_fc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OneApproxOpts *arg1 = (struct OneApproxOpts *) 0 ;
  enum function_class arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OneApproxOpts_fc_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneApproxOpts_fc_set" "', argument " "1"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg1 = (struct OneApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OneApproxOpts_fc_set" "', argument " "2"" of type '" "enum function_class""'");
  } 
  arg2 = (enum function_class)(val2);
  if (arg1) (arg1)->fc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneApproxOpts_fc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OneApproxOpts *arg1 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum function_class result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OneApproxOpts_fc_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneApproxOpts_fc_get" "', argument " "1"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg1 = (struct OneApproxOpts *)(argp1);
  result = (enum function_class) ((arg1)->fc);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneApproxOpts_aopts_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OneApproxOpts *arg1 = (struct OneApproxOpts *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OneApproxOpts_aopts_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneApproxOpts_aopts_set" "', argument " "1"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg1 = (struct OneApproxOpts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OneApproxOpts_aopts_set" "', argument " "2"" of type '" "void *""'"); 
  }
  if (arg1) (arg1)->aopts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneApproxOpts_aopts_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OneApproxOpts *arg1 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OneApproxOpts_aopts_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneApproxOpts_aopts_get" "', argument " "1"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg1 = (struct OneApproxOpts *)(argp1);
  result = (void *) ((arg1)->aopts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OneApproxOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OneApproxOpts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OneApproxOpts")) SWIG_fail;
  result = (struct OneApproxOpts *)calloc(1, sizeof(struct OneApproxOpts));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OneApproxOpts, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OneApproxOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OneApproxOpts *arg1 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OneApproxOpts",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OneApproxOpts, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OneApproxOpts" "', argument " "1"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg1 = (struct OneApproxOpts *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_one_approx_opts_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum function_class arg1 ;
  void *arg2 = (void *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct OneApproxOpts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:one_approx_opts_alloc",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "one_approx_opts_alloc" "', argument " "1"" of type '" "enum function_class""'");
  } 
  arg1 = (enum function_class)(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "one_approx_opts_alloc" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (struct OneApproxOpts *)one_approx_opts_alloc(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_one_approx_opts_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OneApproxOpts *arg1 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:one_approx_opts_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "one_approx_opts_free" "', argument " "1"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg1 = (struct OneApproxOpts *)(argp1);
  one_approx_opts_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_one_approx_opts_free_deep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OneApproxOpts **arg1 = (struct OneApproxOpts **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:one_approx_opts_free_deep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "one_approx_opts_free_deep" "', argument " "1"" of type '" "struct OneApproxOpts **""'"); 
  }
  arg1 = (struct OneApproxOpts **)(argp1);
  one_approx_opts_free_deep(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_one_approx_opts_get_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OneApproxOpts *arg1 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:one_approx_opts_get_nparams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "one_approx_opts_get_nparams" "', argument " "1"" of type '" "struct OneApproxOpts const *""'"); 
  }
  arg1 = (struct OneApproxOpts *)(argp1);
  result = (size_t)one_approx_opts_get_nparams((struct OneApproxOpts const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_one_approx_opts_set_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OneApproxOpts *arg1 = (struct OneApproxOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:one_approx_opts_set_nparams",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "one_approx_opts_set_nparams" "', argument " "1"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg1 = (struct OneApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "one_approx_opts_set_nparams" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  one_approx_opts_set_nparams(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_one_approx_opts_get_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OneApproxOpts *arg1 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:one_approx_opts_get_lb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "one_approx_opts_get_lb" "', argument " "1"" of type '" "struct OneApproxOpts const *""'"); 
  }
  arg1 = (struct OneApproxOpts *)(argp1);
  result = (double)one_approx_opts_get_lb((struct OneApproxOpts const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_one_approx_opts_get_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OneApproxOpts *arg1 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:one_approx_opts_get_ub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "one_approx_opts_get_ub" "', argument " "1"" of type '" "struct OneApproxOpts const *""'"); 
  }
  arg1 = (struct OneApproxOpts *)(argp1);
  result = (double)one_approx_opts_get_ub((struct OneApproxOpts const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_one_approx_opts_linear_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OneApproxOpts *arg1 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:one_approx_opts_linear_p",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "one_approx_opts_linear_p" "', argument " "1"" of type '" "struct OneApproxOpts const *""'"); 
  }
  arg1 = (struct OneApproxOpts *)(argp1);
  result = (int)one_approx_opts_linear_p((struct OneApproxOpts const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multi_approx_opts_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct MultiApproxOpts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:multi_approx_opts_alloc",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "multi_approx_opts_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct MultiApproxOpts *)multi_approx_opts_alloc(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multi_approx_opts_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:multi_approx_opts_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multi_approx_opts_free" "', argument " "1"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  multi_approx_opts_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multi_approx_opts_free_deep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts **arg1 = (struct MultiApproxOpts **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:multi_approx_opts_free_deep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multi_approx_opts_free_deep" "', argument " "1"" of type '" "struct MultiApproxOpts **""'"); 
  }
  arg1 = (struct MultiApproxOpts **)(argp1);
  multi_approx_opts_free_deep(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multi_approx_opts_set_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  size_t arg2 ;
  struct OneApproxOpts *arg3 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:multi_approx_opts_set_dim",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multi_approx_opts_set_dim" "', argument " "1"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multi_approx_opts_set_dim" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "multi_approx_opts_set_dim" "', argument " "3"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg3 = (struct OneApproxOpts *)(argp3);
  multi_approx_opts_set_dim(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multi_approx_opts_set_dim_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  size_t arg2 ;
  struct OneApproxOpts **arg3 = (struct OneApproxOpts **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:multi_approx_opts_set_dim_ref",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multi_approx_opts_set_dim_ref" "', argument " "1"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multi_approx_opts_set_dim_ref" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "multi_approx_opts_set_dim_ref" "', argument " "3"" of type '" "struct OneApproxOpts **""'"); 
  }
  arg3 = (struct OneApproxOpts **)(argp3);
  multi_approx_opts_set_dim_ref(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multi_approx_opts_set_all_same(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  struct OneApproxOpts *arg2 = (struct OneApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:multi_approx_opts_set_all_same",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multi_approx_opts_set_all_same" "', argument " "1"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OneApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "multi_approx_opts_set_all_same" "', argument " "2"" of type '" "struct OneApproxOpts *""'"); 
  }
  arg2 = (struct OneApproxOpts *)(argp2);
  multi_approx_opts_set_all_same(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multi_approx_opts_get_fc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  enum function_class result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:multi_approx_opts_get_fc",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multi_approx_opts_get_fc" "', argument " "1"" of type '" "struct MultiApproxOpts const *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multi_approx_opts_get_fc" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (enum function_class)multi_approx_opts_get_fc((struct MultiApproxOpts const *)arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multi_approx_opts_linear_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:multi_approx_opts_linear_p",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multi_approx_opts_linear_p" "', argument " "1"" of type '" "struct MultiApproxOpts const *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multi_approx_opts_linear_p" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (int)multi_approx_opts_linear_p((struct MultiApproxOpts const *)arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multi_approx_opts_get_aopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  void *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:multi_approx_opts_get_aopts",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multi_approx_opts_get_aopts" "', argument " "1"" of type '" "struct MultiApproxOpts const *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multi_approx_opts_get_aopts" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (void *)multi_approx_opts_get_aopts((struct MultiApproxOpts const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multi_approx_opts_get_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:multi_approx_opts_get_dim",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multi_approx_opts_get_dim" "', argument " "1"" of type '" "struct MultiApproxOpts const *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  result = (size_t)multi_approx_opts_get_dim((struct MultiApproxOpts const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multi_approx_opts_get_dim_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:multi_approx_opts_get_dim_nparams",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multi_approx_opts_get_dim_nparams" "', argument " "1"" of type '" "struct MultiApproxOpts const *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multi_approx_opts_get_dim_nparams" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (size_t)multi_approx_opts_get_dim_nparams((struct MultiApproxOpts const *)arg1,arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multi_approx_opts_set_dim_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:multi_approx_opts_set_dim_nparams",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multi_approx_opts_set_dim_nparams" "', argument " "1"" of type '" "struct MultiApproxOpts *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multi_approx_opts_set_dim_nparams" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "multi_approx_opts_set_dim_nparams" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  multi_approx_opts_set_dim_nparams(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multi_approx_opts_get_dim_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:multi_approx_opts_get_dim_ub",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multi_approx_opts_get_dim_ub" "', argument " "1"" of type '" "struct MultiApproxOpts const *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multi_approx_opts_get_dim_ub" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double)multi_approx_opts_get_dim_ub((struct MultiApproxOpts const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multi_approx_opts_get_dim_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct MultiApproxOpts *arg1 = (struct MultiApproxOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:multi_approx_opts_get_dim_lb",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MultiApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multi_approx_opts_get_dim_lb" "', argument " "1"" of type '" "struct MultiApproxOpts const *""'"); 
  }
  arg1 = (struct MultiApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multi_approx_opts_get_dim_lb" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double)multi_approx_opts_get_dim_lb((struct MultiApproxOpts const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_opt_args_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberOptArgs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":fiber_opt_args_alloc")) SWIG_fail;
  result = (struct FiberOptArgs *)fiber_opt_args_alloc();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FiberOptArgs, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_opt_args_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FiberOptArgs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:fiber_opt_args_init",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fiber_opt_args_init" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct FiberOptArgs *)fiber_opt_args_init(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FiberOptArgs, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_opt_args_set_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberOptArgs *arg1 = (struct FiberOptArgs *) 0 ;
  size_t arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:fiber_opt_args_set_dim",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberOptArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fiber_opt_args_set_dim" "', argument " "1"" of type '" "struct FiberOptArgs *""'"); 
  }
  arg1 = (struct FiberOptArgs *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fiber_opt_args_set_dim" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fiber_opt_args_set_dim" "', argument " "3"" of type '" "void *""'"); 
  }
  fiber_opt_args_set_dim(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_opt_args_bf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct c3Vector **arg2 = (struct c3Vector **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct FiberOptArgs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fiber_opt_args_bf",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fiber_opt_args_bf" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_c3Vector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fiber_opt_args_bf" "', argument " "2"" of type '" "struct c3Vector **""'"); 
  }
  arg2 = (struct c3Vector **)(argp2);
  result = (struct FiberOptArgs *)fiber_opt_args_bf(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FiberOptArgs, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_opt_args_bf_same(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct c3Vector *arg2 = (struct c3Vector *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct FiberOptArgs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fiber_opt_args_bf_same",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fiber_opt_args_bf_same" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_c3Vector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fiber_opt_args_bf_same" "', argument " "2"" of type '" "struct c3Vector *""'"); 
  }
  arg2 = (struct c3Vector *)(argp2);
  result = (struct FiberOptArgs *)fiber_opt_args_bf_same(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FiberOptArgs, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_opt_args_get_opts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberOptArgs *arg1 = (struct FiberOptArgs *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  void *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fiber_opt_args_get_opts",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberOptArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fiber_opt_args_get_opts" "', argument " "1"" of type '" "struct FiberOptArgs const *""'"); 
  }
  arg1 = (struct FiberOptArgs *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fiber_opt_args_get_opts" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (void *)fiber_opt_args_get_opts((struct FiberOptArgs const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_opt_args_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberOptArgs *arg1 = (struct FiberOptArgs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:fiber_opt_args_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberOptArgs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fiber_opt_args_free" "', argument " "1"" of type '" "struct FiberOptArgs *""'"); 
  }
  arg1 = (struct FiberOptArgs *)(argp1);
  fiber_opt_args_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Operator_f_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Operator *arg1 = (struct Operator *) 0 ;
  struct GenericFunction *(*arg2)(struct GenericFunction const *,void *) = (struct GenericFunction *(*)(struct GenericFunction const *,void *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Operator_f_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Operator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_f_set" "', argument " "1"" of type '" "struct Operator *""'"); 
  }
  arg1 = (struct Operator *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_GenericFunction_p_void__p_GenericFunction);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Operator_f_set" "', argument " "2"" of type '" "struct GenericFunction *(*)(struct GenericFunction const *,void *)""'"); 
    }
  }
  if (arg1) (arg1)->f = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Operator_f_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Operator *arg1 = (struct Operator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct GenericFunction *(*result)(struct GenericFunction const *,void *) = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Operator_f_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Operator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_f_get" "', argument " "1"" of type '" "struct Operator *""'"); 
  }
  arg1 = (struct Operator *)(argp1);
  result = (struct GenericFunction *(*)(struct GenericFunction const *,void *)) ((arg1)->f);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__struct_GenericFunction_p_void__p_GenericFunction);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Operator_opts_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Operator *arg1 = (struct Operator *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Operator_opts_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Operator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_opts_set" "', argument " "1"" of type '" "struct Operator *""'"); 
  }
  arg1 = (struct Operator *)(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_opts_set" "', argument " "2"" of type '" "void *""'"); 
  }
  if (arg1) (arg1)->opts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Operator_opts_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Operator *arg1 = (struct Operator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Operator_opts_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Operator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_opts_get" "', argument " "1"" of type '" "struct Operator *""'"); 
  }
  arg1 = (struct Operator *)(argp1);
  result = (void *) ((arg1)->opts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Operator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Operator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Operator")) SWIG_fail;
  result = (struct Operator *)calloc(1, sizeof(struct Operator));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Operator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Operator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Operator *arg1 = (struct Operator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Operator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Operator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Operator" "', argument " "1"" of type '" "struct Operator *""'"); 
  }
  arg1 = (struct Operator *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_GenericFunction_dim_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericFunction_dim_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericFunction_dim_set" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericFunction_dim_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->dim = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericFunction_dim_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericFunction_dim_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericFunction_dim_get" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (size_t) ((arg1)->dim);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericFunction_fc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  enum function_class arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericFunction_fc_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericFunction_fc_set" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericFunction_fc_set" "', argument " "2"" of type '" "enum function_class""'");
  } 
  arg2 = (enum function_class)(val2);
  if (arg1) (arg1)->fc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericFunction_fc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum function_class result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericFunction_fc_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericFunction_fc_get" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (enum function_class) ((arg1)->fc);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericFunction_f_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericFunction_f_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericFunction_f_set" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenericFunction_f_set" "', argument " "2"" of type '" "void *""'"); 
  }
  if (arg1) (arg1)->f = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericFunction_f_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericFunction_f_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericFunction_f_get" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (void *) ((arg1)->f);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericFunction_fargs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericFunction_fargs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericFunction_fargs_set" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenericFunction_fargs_set" "', argument " "2"" of type '" "void *""'"); 
  }
  if (arg1) (arg1)->fargs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericFunction_fargs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericFunction_fargs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericFunction_fargs_get" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (void *) ((arg1)->fargs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_GenericFunction")) SWIG_fail;
  result = (struct GenericFunction *)calloc(1, sizeof(struct GenericFunction));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GenericFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_GenericFunction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GenericFunction" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_generic_function_alloc_base(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_alloc_base",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_alloc_base" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct GenericFunction *)generic_function_alloc_base(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_array_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct GenericFunction **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_array_alloc",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_array_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct GenericFunction **)generic_function_array_alloc(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  enum function_class arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_alloc",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_alloc" "', argument " "2"" of type '" "enum function_class""'");
  } 
  arg2 = (enum function_class)(val2);
  result = (struct GenericFunction *)generic_function_alloc(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_free" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  generic_function_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_array_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction **arg1 = (struct GenericFunction **) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_array_free",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_array_free" "', argument " "1"" of type '" "struct GenericFunction **""'"); 
  }
  arg1 = (struct GenericFunction **)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_array_free" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  generic_function_array_free(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_copy" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (struct GenericFunction *)generic_function_copy((struct GenericFunction const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_copy_pa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  struct GenericFunction *arg2 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_copy_pa",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_copy_pa" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_copy_pa" "', argument " "2"" of type '" "struct GenericFunction *""'"); 
  }
  arg2 = (struct GenericFunction *)(argp2);
  generic_function_copy_pa((struct GenericFunction const *)arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_serialize_generic_function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct GenericFunction *arg2 = (struct GenericFunction *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:serialize_generic_function",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "serialize_generic_function" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "serialize_generic_function" "', argument " "2"" of type '" "struct GenericFunction const *""'"); 
  }
  arg2 = (struct GenericFunction *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "serialize_generic_function" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (unsigned char *)serialize_generic_function(arg1,(struct GenericFunction const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_deserialize_generic_function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct GenericFunction **arg2 = (struct GenericFunction **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:deserialize_generic_function",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deserialize_generic_function" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "deserialize_generic_function" "', argument " "2"" of type '" "struct GenericFunction **""'"); 
  }
  arg2 = (struct GenericFunction **)(argp2);
  result = (unsigned char *)deserialize_generic_function(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_savetxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_savetxt",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_savetxt" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_savetxt" "', argument " "2"" of type '" "FILE *""'"); 
  }
  arg2 = (FILE *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_savetxt" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  generic_function_savetxt((struct GenericFunction const *)arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_loadtxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FILE *arg1 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_loadtxt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_loadtxt" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = (FILE *)(argp1);
  result = (struct GenericFunction *)generic_function_loadtxt(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_generic_function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  size_t arg2 ;
  void *arg3 = (void *) 0 ;
  FILE *arg4 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:print_generic_function",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_generic_function" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "print_generic_function" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "print_generic_function" "', argument " "3"" of type '" "void *""'"); 
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "print_generic_function" "', argument " "4"" of type '" "FILE *""'"); 
  }
  arg4 = (FILE *)(argp4);
  print_generic_function((struct GenericFunction const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_approximate1d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum function_class arg1 ;
  void *arg2 = (void *) 0 ;
  struct Fwrap *arg3 = (struct Fwrap *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_approximate1d",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_approximate1d" "', argument " "1"" of type '" "enum function_class""'");
  } 
  arg1 = (enum function_class)(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_approximate1d" "', argument " "2"" of type '" "void *""'"); 
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_approximate1d" "', argument " "3"" of type '" "struct Fwrap *""'"); 
  }
  arg3 = (struct Fwrap *)(argp3);
  result = (struct GenericFunction *)generic_function_approximate1d(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_regress1d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Regress1DOpts *arg1 = (struct Regress1DOpts *) 0 ;
  struct c3Opt *arg2 = (struct c3Opt *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_regress1d",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Regress1DOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_regress1d" "', argument " "1"" of type '" "struct Regress1DOpts *""'"); 
  }
  arg1 = (struct Regress1DOpts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_regress1d" "', argument " "2"" of type '" "struct c3Opt *""'"); 
  }
  arg2 = (struct c3Opt *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_regress1d" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  result = (struct GenericFunction *)generic_function_regress1d(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_create_with_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum function_class arg1 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  double *arg4 = (double *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:generic_function_create_with_params",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_create_with_params" "', argument " "1"" of type '" "enum function_class""'");
  } 
  arg1 = (enum function_class)(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_create_with_params" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_create_with_params" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_create_with_params" "', argument " "4"" of type '" "double const *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (struct GenericFunction *)generic_function_create_with_params(arg1,arg2,arg3,(double const *)arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_zero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum function_class arg1 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_zero",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_zero" "', argument " "1"" of type '" "enum function_class""'");
  } 
  arg1 = (enum function_class)(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_zero" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_zero" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  result = (struct GenericFunction *)generic_function_zero(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_constant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  enum function_class arg2 ;
  void *arg3 = (void *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_constant",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_constant" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_constant" "', argument " "2"" of type '" "enum function_class""'");
  } 
  arg2 = (enum function_class)(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_constant" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (struct GenericFunction *)generic_function_constant(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_linear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  enum function_class arg3 ;
  void *arg4 = (void *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:generic_function_linear",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_linear" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_linear" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_linear" "', argument " "3"" of type '" "enum function_class""'");
  } 
  arg3 = (enum function_class)(val3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_linear" "', argument " "4"" of type '" "void *""'"); 
  }
  result = (struct GenericFunction *)generic_function_linear(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_linear_update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_linear_update",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_linear_update" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_linear_update" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_linear_update" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  result = (int)generic_function_linear_update(arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_quadratic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  enum function_class arg3 ;
  void *arg4 = (void *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:generic_function_quadratic",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_quadratic" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_quadratic" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_quadratic" "', argument " "3"" of type '" "enum function_class""'");
  } 
  arg3 = (enum function_class)(val3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_quadratic" "', argument " "4"" of type '" "void *""'"); 
  }
  result = (struct GenericFunction *)generic_function_quadratic(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_poly_randu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum poly_type arg1 ;
  size_t arg2 ;
  double arg3 ;
  double arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:generic_function_poly_randu",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_poly_randu" "', argument " "1"" of type '" "enum poly_type""'");
  } 
  arg1 = (enum poly_type)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_poly_randu" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_poly_randu" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "generic_function_poly_randu" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  result = (struct GenericFunction *)generic_function_poly_randu(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_onezero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum function_class arg1 ;
  double arg2 ;
  size_t arg3 ;
  double *arg4 = (double *) 0 ;
  double arg5 ;
  double arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:generic_function_onezero",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_onezero" "', argument " "1"" of type '" "enum function_class""'");
  } 
  arg1 = (enum function_class)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_onezero" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_onezero" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_onezero" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "generic_function_onezero" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "generic_function_onezero" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = (double)(val6);
  result = (struct GenericFunction *)generic_function_onezero(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_lin_comb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct GenericFunction **arg2 = (struct GenericFunction **) 0 ;
  double *arg3 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_lin_comb",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_lin_comb" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_lin_comb" "', argument " "2"" of type '" "struct GenericFunction **""'"); 
  }
  arg2 = (struct GenericFunction **)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_lin_comb" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (struct GenericFunction *)generic_function_lin_comb(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_lin_comb2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct GenericFunction **arg3 = (struct GenericFunction **) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:generic_function_lin_comb2",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_lin_comb2" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_lin_comb2" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_lin_comb2" "', argument " "3"" of type '" "struct GenericFunction **""'"); 
  }
  arg3 = (struct GenericFunction **)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "generic_function_lin_comb2" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "generic_function_lin_comb2" "', argument " "5"" of type '" "double const *""'"); 
  }
  arg5 = (double *)(argp5);
  result = (struct GenericFunction *)generic_function_lin_comb2(arg1,arg2,arg3,arg4,(double const *)arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_deriv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_deriv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_deriv" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (struct GenericFunction *)generic_function_deriv((struct GenericFunction const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_dderiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_dderiv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_dderiv" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (struct GenericFunction *)generic_function_dderiv((struct GenericFunction const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_dderiv_periodic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_dderiv_periodic",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_dderiv_periodic" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (struct GenericFunction *)generic_function_dderiv_periodic((struct GenericFunction const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_create_nodal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_create_nodal",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_create_nodal" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_create_nodal" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_create_nodal" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (struct GenericFunction *)generic_function_create_nodal(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_sum_prod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct GenericFunction **arg3 = (struct GenericFunction **) 0 ;
  size_t arg4 ;
  struct GenericFunction **arg5 = (struct GenericFunction **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:generic_function_sum_prod",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_sum_prod" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_sum_prod" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_sum_prod" "', argument " "3"" of type '" "struct GenericFunction **""'"); 
  }
  arg3 = (struct GenericFunction **)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "generic_function_sum_prod" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "generic_function_sum_prod" "', argument " "5"" of type '" "struct GenericFunction **""'"); 
  }
  arg5 = (struct GenericFunction **)(argp5);
  result = (struct GenericFunction *)generic_function_sum_prod(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_prod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  struct GenericFunction *arg2 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_prod",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_prod" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_prod" "', argument " "2"" of type '" "struct GenericFunction *""'"); 
  }
  arg2 = (struct GenericFunction *)(argp2);
  result = (struct GenericFunction *)generic_function_prod(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_daxpby(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct GenericFunction *arg2 = (struct GenericFunction *) 0 ;
  double arg3 ;
  struct GenericFunction *arg4 = (struct GenericFunction *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct GenericFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:generic_function_daxpby",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_daxpby" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_daxpby" "', argument " "2"" of type '" "struct GenericFunction const *""'"); 
  }
  arg2 = (struct GenericFunction *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_daxpby" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_daxpby" "', argument " "4"" of type '" "struct GenericFunction const *""'"); 
  }
  arg4 = (struct GenericFunction *)(argp4);
  result = (struct GenericFunction *)generic_function_daxpby(arg1,(struct GenericFunction const *)arg2,arg3,(struct GenericFunction const *)arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_array_daxpby(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double arg2 ;
  size_t arg3 ;
  struct GenericFunction **arg4 = (struct GenericFunction **) 0 ;
  double arg5 ;
  size_t arg6 ;
  struct GenericFunction **arg7 = (struct GenericFunction **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  struct GenericFunction **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:generic_function_array_daxpby",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_array_daxpby" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_array_daxpby" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_array_daxpby" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_array_daxpby" "', argument " "4"" of type '" "struct GenericFunction **""'"); 
  }
  arg4 = (struct GenericFunction **)(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "generic_function_array_daxpby" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "generic_function_array_daxpby" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "generic_function_array_daxpby" "', argument " "7"" of type '" "struct GenericFunction **""'"); 
  }
  arg7 = (struct GenericFunction **)(argp7);
  result = (struct GenericFunction **)generic_function_array_daxpby(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_get_num_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_get_num_params",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_get_num_params" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (size_t)generic_function_get_num_params((struct GenericFunction const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_get_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_get_lb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_get_lb" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (double)generic_function_get_lb((struct GenericFunction const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_get_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_get_ub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_get_ub" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (double)generic_function_get_ub((struct GenericFunction const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_get_fc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum function_class result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_get_fc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_get_fc" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (enum function_class)generic_function_get_fc((struct GenericFunction const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_is_kristoffel_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_is_kristoffel_active",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_is_kristoffel_active" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (int)generic_function_is_kristoffel_active((struct GenericFunction const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_activate_kristoffel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_activate_kristoffel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_activate_kristoffel" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  generic_function_activate_kristoffel(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_deactivate_kristoffel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_deactivate_kristoffel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_deactivate_kristoffel" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  generic_function_deactivate_kristoffel(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_get_kristoffel_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_get_kristoffel_weight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_get_kristoffel_weight" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_get_kristoffel_weight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)generic_function_get_kristoffel_weight((struct GenericFunction const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_get_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_get_params",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_get_params" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_get_params" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (size_t)generic_function_get_params((struct GenericFunction const *)arg1,arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_get_params_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_get_params_ref",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_get_params_ref" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_get_params_ref" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (double *)generic_function_get_params_ref((struct GenericFunction const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_update_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_update_params",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_update_params" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_update_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_update_params" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (int)generic_function_update_params(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_roundt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction **arg1 = (struct GenericFunction **) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_roundt",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_roundt" "', argument " "1"" of type '" "struct GenericFunction **""'"); 
  }
  arg1 = (struct GenericFunction **)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_roundt" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  generic_function_roundt(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_array_onezero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction **arg1 = (struct GenericFunction **) 0 ;
  size_t arg2 ;
  enum function_class arg3 ;
  size_t arg4 ;
  size_t *arg5 = (size_t *) 0 ;
  double *arg6 = (double *) 0 ;
  void *arg7 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:generic_function_array_onezero",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_array_onezero" "', argument " "1"" of type '" "struct GenericFunction **""'"); 
  }
  arg1 = (struct GenericFunction **)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_array_onezero" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_array_onezero" "', argument " "3"" of type '" "enum function_class""'");
  } 
  arg3 = (enum function_class)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "generic_function_array_onezero" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "generic_function_array_onezero" "', argument " "5"" of type '" "size_t *""'"); 
  }
  arg5 = (size_t *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "generic_function_array_onezero" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6,SWIG_as_voidptrptr(&arg7), 0, 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "generic_function_array_onezero" "', argument " "7"" of type '" "void *""'"); 
  }
  generic_function_array_onezero(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_flip_sign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_flip_sign",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_flip_sign" "', argument " "1"" of type '" "struct GenericFunction *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  generic_function_flip_sign(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_array_flip_sign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct GenericFunction **arg3 = (struct GenericFunction **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_array_flip_sign",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_array_flip_sign" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_array_flip_sign" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_array_flip_sign" "', argument " "3"" of type '" "struct GenericFunction **""'"); 
  }
  arg3 = (struct GenericFunction **)(argp3);
  generic_function_array_flip_sign(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_weighted_sum_pa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct GenericFunction *arg2 = (struct GenericFunction *) 0 ;
  double arg3 ;
  struct GenericFunction *arg4 = (struct GenericFunction *) 0 ;
  struct GenericFunction **arg5 = (struct GenericFunction **) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:generic_function_weighted_sum_pa",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_weighted_sum_pa" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_weighted_sum_pa" "', argument " "2"" of type '" "struct GenericFunction *""'"); 
  }
  arg2 = (struct GenericFunction *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_weighted_sum_pa" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_weighted_sum_pa" "', argument " "4"" of type '" "struct GenericFunction *""'"); 
  }
  arg4 = (struct GenericFunction *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "generic_function_weighted_sum_pa" "', argument " "5"" of type '" "struct GenericFunction **""'"); 
  }
  arg5 = (struct GenericFunction **)(argp5);
  generic_function_weighted_sum_pa(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_sum3_up(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct GenericFunction *arg2 = (struct GenericFunction *) 0 ;
  double arg3 ;
  struct GenericFunction *arg4 = (struct GenericFunction *) 0 ;
  double arg5 ;
  struct GenericFunction *arg6 = (struct GenericFunction *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:generic_function_sum3_up",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_sum3_up" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_sum3_up" "', argument " "2"" of type '" "struct GenericFunction *""'"); 
  }
  arg2 = (struct GenericFunction *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_sum3_up" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_sum3_up" "', argument " "4"" of type '" "struct GenericFunction *""'"); 
  }
  arg4 = (struct GenericFunction *)(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "generic_function_sum3_up" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "generic_function_sum3_up" "', argument " "6"" of type '" "struct GenericFunction *""'"); 
  }
  arg6 = (struct GenericFunction *)(argp6);
  generic_function_sum3_up(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_axpy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct GenericFunction *arg2 = (struct GenericFunction *) 0 ;
  struct GenericFunction *arg3 = (struct GenericFunction *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_axpy",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_axpy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_axpy" "', argument " "2"" of type '" "struct GenericFunction const *""'"); 
  }
  arg2 = (struct GenericFunction *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_axpy" "', argument " "3"" of type '" "struct GenericFunction *""'"); 
  }
  arg3 = (struct GenericFunction *)(argp3);
  result = (int)generic_function_axpy(arg1,(struct GenericFunction const *)arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_array_axpy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double arg2 ;
  struct GenericFunction **arg3 = (struct GenericFunction **) 0 ;
  struct GenericFunction **arg4 = (struct GenericFunction **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:generic_function_array_axpy",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_array_axpy" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_array_axpy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_array_axpy" "', argument " "3"" of type '" "struct GenericFunction **""'"); 
  }
  arg3 = (struct GenericFunction **)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_array_axpy" "', argument " "4"" of type '" "struct GenericFunction **""'"); 
  }
  arg4 = (struct GenericFunction **)(argp4);
  result = (int)generic_function_array_axpy(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct GenericFunction *arg2 = (struct GenericFunction *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_scale",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_scale" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_scale" "', argument " "2"" of type '" "struct GenericFunction *""'"); 
  }
  arg2 = (struct GenericFunction *)(argp2);
  generic_function_scale(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_array_scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct GenericFunction **arg2 = (struct GenericFunction **) 0 ;
  size_t arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_array_scale",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_array_scale" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_array_scale" "', argument " "2"" of type '" "struct GenericFunction **""'"); 
  }
  arg2 = (struct GenericFunction **)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_array_scale" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  generic_function_array_scale(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_kronh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  double *arg6 = (double *) 0 ;
  struct GenericFunction **arg7 = (struct GenericFunction **) 0 ;
  struct GenericFunction **arg8 = (struct GenericFunction **) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:generic_function_kronh",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_kronh" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_kronh" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_kronh" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "generic_function_kronh" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "generic_function_kronh" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "generic_function_kronh" "', argument " "6"" of type '" "double const *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "generic_function_kronh" "', argument " "7"" of type '" "struct GenericFunction **""'"); 
  }
  arg7 = (struct GenericFunction **)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "generic_function_kronh" "', argument " "8"" of type '" "struct GenericFunction **""'"); 
  }
  arg8 = (struct GenericFunction **)(argp8);
  generic_function_kronh(arg1,arg2,arg3,arg4,arg5,(double const *)arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_kronh2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  struct GenericFunction **arg6 = (struct GenericFunction **) 0 ;
  struct GenericFunction **arg7 = (struct GenericFunction **) 0 ;
  struct GenericFunction **arg8 = (struct GenericFunction **) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:generic_function_kronh2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_kronh2" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_kronh2" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_kronh2" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "generic_function_kronh2" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "generic_function_kronh2" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "generic_function_kronh2" "', argument " "6"" of type '" "struct GenericFunction **""'"); 
  }
  arg6 = (struct GenericFunction **)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "generic_function_kronh2" "', argument " "7"" of type '" "struct GenericFunction **""'"); 
  }
  arg7 = (struct GenericFunction **)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "generic_function_kronh2" "', argument " "8"" of type '" "struct GenericFunction **""'"); 
  }
  arg8 = (struct GenericFunction **)(argp8);
  generic_function_kronh2(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_array_orth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct GenericFunction **arg2 = (struct GenericFunction **) 0 ;
  enum function_class arg3 ;
  void *arg4 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:generic_function_array_orth",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_array_orth" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_array_orth" "', argument " "2"" of type '" "struct GenericFunction **""'"); 
  }
  arg2 = (struct GenericFunction **)(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_array_orth" "', argument " "3"" of type '" "enum function_class""'");
  } 
  arg3 = (enum function_class)(val3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_array_orth" "', argument " "4"" of type '" "void *""'"); 
  }
  generic_function_array_orth(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_array_daxpby2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double arg2 ;
  size_t arg3 ;
  struct GenericFunction **arg4 = (struct GenericFunction **) 0 ;
  double arg5 ;
  size_t arg6 ;
  struct GenericFunction **arg7 = (struct GenericFunction **) 0 ;
  size_t arg8 ;
  struct GenericFunction **arg9 = (struct GenericFunction **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:generic_function_array_daxpby2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_array_daxpby2" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_array_daxpby2" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_array_daxpby2" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_array_daxpby2" "', argument " "4"" of type '" "struct GenericFunction **""'"); 
  }
  arg4 = (struct GenericFunction **)(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "generic_function_array_daxpby2" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "generic_function_array_daxpby2" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "generic_function_array_daxpby2" "', argument " "7"" of type '" "struct GenericFunction **""'"); 
  }
  arg7 = (struct GenericFunction **)(argp7);
  ecode8 = SWIG_AsVal_size_t(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "generic_function_array_daxpby2" "', argument " "8"" of type '" "size_t""'");
  } 
  arg8 = (size_t)(val8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "generic_function_array_daxpby2" "', argument " "9"" of type '" "struct GenericFunction **""'"); 
  }
  arg9 = (struct GenericFunction **)(argp9);
  generic_function_array_daxpby2(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_1d_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_1d_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_1d_eval" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_1d_eval" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)generic_function_1d_eval((struct GenericFunction const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_deriv_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_deriv_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_deriv_eval" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_deriv_eval" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)generic_function_deriv_eval((struct GenericFunction const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_1d_evalN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:generic_function_1d_evalN",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_1d_evalN" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_1d_evalN" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_1d_evalN" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "generic_function_1d_evalN" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "generic_function_1d_evalN" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "generic_function_1d_evalN" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  generic_function_1d_evalN((struct GenericFunction const *)arg1,arg2,(double const *)arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_1d_eval_ind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_1d_eval_ind",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_1d_eval_ind" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_1d_eval_ind" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double)generic_function_1d_eval_ind((struct GenericFunction const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_1darray_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct GenericFunction **arg2 = (struct GenericFunction **) 0 ;
  double arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_1darray_eval",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_1darray_eval" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_1darray_eval" "', argument " "2"" of type '" "struct GenericFunction **""'"); 
  }
  arg2 = (struct GenericFunction **)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_1darray_eval" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  result = (double *)generic_function_1darray_eval(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_1darray_eval_piv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction **arg1 = (struct GenericFunction **) 0 ;
  struct Pivot *arg2 = (struct Pivot *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_1darray_eval_piv",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_1darray_eval_piv" "', argument " "1"" of type '" "struct GenericFunction **""'"); 
  }
  arg1 = (struct GenericFunction **)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pivot, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_1darray_eval_piv" "', argument " "2"" of type '" "struct Pivot *""'"); 
  }
  arg2 = (struct Pivot *)(argp2);
  result = (double)generic_function_1darray_eval_piv(arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_1darray_eval2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct GenericFunction **arg2 = (struct GenericFunction **) 0 ;
  double arg3 ;
  double *arg4 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:generic_function_1darray_eval2",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_1darray_eval2" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_1darray_eval2" "', argument " "2"" of type '" "struct GenericFunction **""'"); 
  }
  arg2 = (struct GenericFunction **)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_1darray_eval2" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_1darray_eval2" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  generic_function_1darray_eval2(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_1darray_eval2N(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct GenericFunction **arg2 = (struct GenericFunction **) 0 ;
  size_t arg3 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  double *arg6 = (double *) 0 ;
  size_t arg7 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:generic_function_1darray_eval2N",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_1darray_eval2N" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_1darray_eval2N" "', argument " "2"" of type '" "struct GenericFunction **""'"); 
  }
  arg2 = (struct GenericFunction **)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_1darray_eval2N" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_1darray_eval2N" "', argument " "4"" of type '" "double const *""'"); 
  }
  arg4 = (double *)(argp4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "generic_function_1darray_eval2N" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "generic_function_1darray_eval2N" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  ecode7 = SWIG_AsVal_size_t(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "generic_function_1darray_eval2N" "', argument " "7"" of type '" "size_t""'");
  } 
  arg7 = (size_t)(val7);
  generic_function_1darray_eval2N(arg1,arg2,arg3,(double const *)arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_1darray_eval2_ind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct GenericFunction **arg2 = (struct GenericFunction **) 0 ;
  size_t arg3 ;
  double *arg4 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:generic_function_1darray_eval2_ind",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_1darray_eval2_ind" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_1darray_eval2_ind" "', argument " "2"" of type '" "struct GenericFunction **""'"); 
  }
  arg2 = (struct GenericFunction **)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_1darray_eval2_ind" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_1darray_eval2_ind" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  generic_function_1darray_eval2_ind(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_param_grad_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:generic_function_param_grad_eval",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_param_grad_eval" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_param_grad_eval" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_param_grad_eval" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_param_grad_eval" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (int)generic_function_param_grad_eval((struct GenericFunction const *)arg1,arg2,(double const *)arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_param_grad_eval2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  double arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_param_grad_eval2",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_param_grad_eval2" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_param_grad_eval2" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_param_grad_eval2" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (double)generic_function_param_grad_eval2((struct GenericFunction const *)arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_integrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_integrate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_integrate" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (double)generic_function_integrate((struct GenericFunction const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_integrate_weighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_integrate_weighted",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_integrate_weighted" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (double)generic_function_integrate_weighted((struct GenericFunction const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:generic_function_norm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_norm" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  result = (double)generic_function_norm((struct GenericFunction const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_inner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  struct GenericFunction *arg2 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_inner",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_inner" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_inner" "', argument " "2"" of type '" "struct GenericFunction const *""'"); 
  }
  arg2 = (struct GenericFunction *)(argp2);
  result = (double)generic_function_inner((struct GenericFunction const *)arg1,(struct GenericFunction const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_inner_weighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  struct GenericFunction *arg2 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_inner_weighted",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_inner_weighted" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_inner_weighted" "', argument " "2"" of type '" "struct GenericFunction const *""'"); 
  }
  arg2 = (struct GenericFunction *)(argp2);
  result = (double)generic_function_inner_weighted((struct GenericFunction const *)arg1,(struct GenericFunction const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_inner_sum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct GenericFunction **arg3 = (struct GenericFunction **) 0 ;
  size_t arg4 ;
  struct GenericFunction **arg5 = (struct GenericFunction **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:generic_function_inner_sum",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_inner_sum" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_inner_sum" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_inner_sum" "', argument " "3"" of type '" "struct GenericFunction **""'"); 
  }
  arg3 = (struct GenericFunction **)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "generic_function_inner_sum" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "generic_function_inner_sum" "', argument " "5"" of type '" "struct GenericFunction **""'"); 
  }
  arg5 = (struct GenericFunction **)(argp5);
  result = (double)generic_function_inner_sum(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_inner_weighted_sum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct GenericFunction **arg3 = (struct GenericFunction **) 0 ;
  size_t arg4 ;
  struct GenericFunction **arg5 = (struct GenericFunction **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:generic_function_inner_weighted_sum",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_inner_weighted_sum" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_inner_weighted_sum" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_inner_weighted_sum" "', argument " "3"" of type '" "struct GenericFunction **""'"); 
  }
  arg3 = (struct GenericFunction **)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "generic_function_inner_weighted_sum" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "generic_function_inner_weighted_sum" "', argument " "5"" of type '" "struct GenericFunction **""'"); 
  }
  arg5 = (struct GenericFunction **)(argp5);
  result = (double)generic_function_inner_weighted_sum(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_norm2diff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  struct GenericFunction *arg2 = (struct GenericFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:generic_function_norm2diff",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_norm2diff" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_norm2diff" "', argument " "2"" of type '" "struct GenericFunction const *""'"); 
  }
  arg2 = (struct GenericFunction *)(argp2);
  result = (double)generic_function_norm2diff((struct GenericFunction const *)arg1,(struct GenericFunction const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_array_norm2diff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct GenericFunction **arg2 = (struct GenericFunction **) 0 ;
  size_t arg3 ;
  struct GenericFunction **arg4 = (struct GenericFunction **) 0 ;
  size_t arg5 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:generic_function_array_norm2diff",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_array_norm2diff" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_array_norm2diff" "', argument " "2"" of type '" "struct GenericFunction **""'"); 
  }
  arg2 = (struct GenericFunction **)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_array_norm2diff" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_array_norm2diff" "', argument " "4"" of type '" "struct GenericFunction **""'"); 
  }
  arg4 = (struct GenericFunction **)(argp4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "generic_function_array_norm2diff" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  result = (double)generic_function_array_norm2diff(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_integral_array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct GenericFunction **arg3 = (struct GenericFunction **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_integral_array",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_integral_array" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_integral_array" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_integral_array" "', argument " "3"" of type '" "struct GenericFunction **""'"); 
  }
  arg3 = (struct GenericFunction **)(argp3);
  result = (double *)generic_function_integral_array(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_array_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct GenericFunction **arg3 = (struct GenericFunction **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_array_norm",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_array_norm" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_array_norm" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_array_norm" "', argument " "3"" of type '" "struct GenericFunction **""'"); 
  }
  arg3 = (struct GenericFunction **)(argp3);
  result = (double)generic_function_array_norm(arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_absmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  double *arg2 = (double *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_absmax",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_absmax" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_absmax" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_absmax" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (double)generic_function_absmax((struct GenericFunction const *)arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_absmax_gen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:generic_function_absmax_gen",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_absmax_gen" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "generic_function_absmax_gen" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "generic_function_absmax_gen" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_absmax_gen" "', argument " "4"" of type '" "void *""'"); 
  }
  result = (double)generic_function_absmax_gen((struct GenericFunction const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_array_absmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct GenericFunction **arg3 = (struct GenericFunction **) 0 ;
  size_t *arg4 = (size_t *) 0 ;
  double *arg5 = (double *) 0 ;
  void *arg6 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:generic_function_array_absmax",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_array_absmax" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_array_absmax" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_array_absmax" "', argument " "3"" of type '" "struct GenericFunction **""'"); 
  }
  arg3 = (struct GenericFunction **)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_array_absmax" "', argument " "4"" of type '" "size_t *""'"); 
  }
  arg4 = (size_t *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "generic_function_array_absmax" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "generic_function_array_absmax" "', argument " "6"" of type '" "void *""'"); 
  }
  result = (double)generic_function_array_absmax(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_array_absmax_piv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct GenericFunction **arg3 = (struct GenericFunction **) 0 ;
  struct Pivot *arg4 = (struct Pivot *) 0 ;
  void *arg5 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:generic_function_array_absmax_piv",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "generic_function_array_absmax_piv" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_array_absmax_piv" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_array_absmax_piv" "', argument " "3"" of type '" "struct GenericFunction **""'"); 
  }
  arg3 = (struct GenericFunction **)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pivot, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "generic_function_array_absmax_piv" "', argument " "4"" of type '" "struct Pivot *""'"); 
  }
  arg4 = (struct Pivot *)(argp4);
  res5 = SWIG_ConvertPtr(obj4,SWIG_as_voidptrptr(&arg5), 0, 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "generic_function_array_absmax_piv" "', argument " "5"" of type '" "void *""'"); 
  }
  result = (double)generic_function_array_absmax_piv(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_1d_opts_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum approx_type arg1 ;
  enum regress_type arg2 ;
  size_t arg3 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  struct Regress1DOpts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:regress_1d_opts_create",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "regress_1d_opts_create" "', argument " "1"" of type '" "enum approx_type""'");
  } 
  arg1 = (enum approx_type)(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "regress_1d_opts_create" "', argument " "2"" of type '" "enum regress_type""'");
  } 
  arg2 = (enum regress_type)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "regress_1d_opts_create" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "regress_1d_opts_create" "', argument " "4"" of type '" "double const *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "regress_1d_opts_create" "', argument " "5"" of type '" "double const *""'"); 
  }
  arg5 = (double *)(argp5);
  result = (struct Regress1DOpts *)regress_1d_opts_create(arg1,arg2,arg3,(double const *)arg4,(double const *)arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Regress1DOpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_1d_opts_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Regress1DOpts *arg1 = (struct Regress1DOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:regress_1d_opts_destroy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Regress1DOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_1d_opts_destroy" "', argument " "1"" of type '" "struct Regress1DOpts *""'"); 
  }
  arg1 = (struct Regress1DOpts *)(argp1);
  regress_1d_opts_destroy(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_1d_opts_set_parametric_form(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Regress1DOpts *arg1 = (struct Regress1DOpts *) 0 ;
  enum function_class arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:regress_1d_opts_set_parametric_form",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Regress1DOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_1d_opts_set_parametric_form" "', argument " "1"" of type '" "struct Regress1DOpts *""'"); 
  }
  arg1 = (struct Regress1DOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "regress_1d_opts_set_parametric_form" "', argument " "2"" of type '" "enum function_class""'");
  } 
  arg2 = (enum function_class)(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "regress_1d_opts_set_parametric_form" "', argument " "3"" of type '" "void *""'"); 
  }
  regress_1d_opts_set_parametric_form(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_1d_opts_set_initial_parameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Regress1DOpts *arg1 = (struct Regress1DOpts *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:regress_1d_opts_set_initial_parameters",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Regress1DOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_1d_opts_set_initial_parameters" "', argument " "1"" of type '" "struct Regress1DOpts *""'"); 
  }
  arg1 = (struct Regress1DOpts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "regress_1d_opts_set_initial_parameters" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  regress_1d_opts_set_initial_parameters(arg1,(double const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_function_squared_norm_param_grad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct GenericFunction *arg1 = (struct GenericFunction *) 0 ;
  double arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:generic_function_squared_norm_param_grad",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GenericFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_function_squared_norm_param_grad" "', argument " "1"" of type '" "struct GenericFunction const *""'"); 
  }
  arg1 = (struct GenericFunction *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_function_squared_norm_param_grad" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_function_squared_norm_param_grad" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (int)generic_function_squared_norm_param_grad((struct GenericFunction const *)arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_1d_opts_set_regularization_penalty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Regress1DOpts *arg1 = (struct Regress1DOpts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:regress_1d_opts_set_regularization_penalty",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Regress1DOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_1d_opts_set_regularization_penalty" "', argument " "1"" of type '" "struct Regress1DOpts *""'"); 
  }
  arg1 = (struct Regress1DOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "regress_1d_opts_set_regularization_penalty" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  regress_1d_opts_set_regularization_penalty(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_regress_1d_opts_set_RKHS_decay_rate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Regress1DOpts *arg1 = (struct Regress1DOpts *) 0 ;
  enum coeff_decay_type arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:regress_1d_opts_set_RKHS_decay_rate",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Regress1DOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "regress_1d_opts_set_RKHS_decay_rate" "', argument " "1"" of type '" "struct Regress1DOpts *""'"); 
  }
  arg1 = (struct Regress1DOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "regress_1d_opts_set_RKHS_decay_rate" "', argument " "2"" of type '" "enum coeff_decay_type""'");
  } 
  arg2 = (enum coeff_decay_type)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "regress_1d_opts_set_RKHS_decay_rate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  regress_1d_opts_set_RKHS_decay_rate(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_LSregress_cost(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  void *arg4 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:param_LSregress_cost",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "param_LSregress_cost" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "param_LSregress_cost" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "param_LSregress_cost" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "param_LSregress_cost" "', argument " "4"" of type '" "void *""'"); 
  }
  result = (double)param_LSregress_cost(arg1,(double const *)arg2,arg3,arg4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_RLS2regress_cost(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  void *arg4 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:param_RLS2regress_cost",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "param_RLS2regress_cost" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "param_RLS2regress_cost" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "param_RLS2regress_cost" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "param_RLS2regress_cost" "', argument " "4"" of type '" "void *""'"); 
  }
  result = (double)param_RLS2regress_cost(arg1,(double const *)arg2,arg3,arg4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_RLSD2regress_cost(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  void *arg4 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:param_RLSD2regress_cost",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "param_RLSD2regress_cost" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "param_RLSD2regress_cost" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "param_RLSD2regress_cost" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "param_RLSD2regress_cost" "', argument " "4"" of type '" "void *""'"); 
  }
  result = (double)param_RLSD2regress_cost(arg1,(double const *)arg2,arg3,arg4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_RLSRKHSregress_cost(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  void *arg4 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:param_RLSRKHSregress_cost",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "param_RLSRKHSregress_cost" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "param_RLSRKHSregress_cost" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "param_RLSRKHSregress_cost" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "param_RLSRKHSregress_cost" "', argument " "4"" of type '" "void *""'"); 
  }
  result = (double)param_RLSRKHSregress_cost(arg1,(double const *)arg2,arg3,arg4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FiberCut_fpoint_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *arg1 = (struct FiberCut *) 0 ;
  union func_type *arg2 = (union func_type *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FiberCut_fpoint_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberCut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiberCut_fpoint_set" "', argument " "1"" of type '" "struct FiberCut *""'"); 
  }
  arg1 = (struct FiberCut *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_func_type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiberCut_fpoint_set" "', argument " "2"" of type '" "union func_type *""'"); 
  }
  arg2 = (union func_type *)(argp2);
  if (arg1) (arg1)->fpoint = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FiberCut_fpoint_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *arg1 = (struct FiberCut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  union func_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FiberCut_fpoint_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberCut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiberCut_fpoint_get" "', argument " "1"" of type '" "struct FiberCut *""'"); 
  }
  arg1 = (struct FiberCut *)(argp1);
  result = (union func_type *)& ((arg1)->fpoint);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_func_type, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FiberCut_totdim_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *arg1 = (struct FiberCut *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FiberCut_totdim_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberCut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiberCut_totdim_set" "', argument " "1"" of type '" "struct FiberCut *""'"); 
  }
  arg1 = (struct FiberCut *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiberCut_totdim_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->totdim = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FiberCut_totdim_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *arg1 = (struct FiberCut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FiberCut_totdim_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberCut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiberCut_totdim_get" "', argument " "1"" of type '" "struct FiberCut *""'"); 
  }
  arg1 = (struct FiberCut *)(argp1);
  result = (size_t) ((arg1)->totdim);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FiberCut_dimcut_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *arg1 = (struct FiberCut *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FiberCut_dimcut_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberCut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiberCut_dimcut_set" "', argument " "1"" of type '" "struct FiberCut *""'"); 
  }
  arg1 = (struct FiberCut *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiberCut_dimcut_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->dimcut = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FiberCut_dimcut_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *arg1 = (struct FiberCut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FiberCut_dimcut_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberCut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiberCut_dimcut_get" "', argument " "1"" of type '" "struct FiberCut *""'"); 
  }
  arg1 = (struct FiberCut *)(argp1);
  result = (size_t) ((arg1)->dimcut);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FiberCut_ftype_flag_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *arg1 = (struct FiberCut *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FiberCut_ftype_flag_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberCut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiberCut_ftype_flag_set" "', argument " "1"" of type '" "struct FiberCut *""'"); 
  }
  arg1 = (struct FiberCut *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiberCut_ftype_flag_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->ftype_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FiberCut_ftype_flag_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *arg1 = (struct FiberCut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FiberCut_ftype_flag_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberCut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiberCut_ftype_flag_get" "', argument " "1"" of type '" "struct FiberCut *""'"); 
  }
  arg1 = (struct FiberCut *)(argp1);
  result = (int) ((arg1)->ftype_flag);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FiberCut_args_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *arg1 = (struct FiberCut *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FiberCut_args_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberCut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiberCut_args_set" "', argument " "1"" of type '" "struct FiberCut *""'"); 
  }
  arg1 = (struct FiberCut *)(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiberCut_args_set" "', argument " "2"" of type '" "void *""'"); 
  }
  if (arg1) (arg1)->args = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FiberCut_args_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *arg1 = (struct FiberCut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FiberCut_args_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberCut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiberCut_args_get" "', argument " "1"" of type '" "struct FiberCut *""'"); 
  }
  arg1 = (struct FiberCut *)(argp1);
  result = (void *) ((arg1)->args);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FiberCut_vals_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *arg1 = (struct FiberCut *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FiberCut_vals_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberCut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiberCut_vals_set" "', argument " "1"" of type '" "struct FiberCut *""'"); 
  }
  arg1 = (struct FiberCut *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiberCut_vals_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->vals = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FiberCut_vals_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *arg1 = (struct FiberCut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FiberCut_vals_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberCut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiberCut_vals_get" "', argument " "1"" of type '" "struct FiberCut *""'"); 
  }
  arg1 = (struct FiberCut *)(argp1);
  result = (double *) ((arg1)->vals);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FiberCut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FiberCut")) SWIG_fail;
  result = (struct FiberCut *)calloc(1, sizeof(struct FiberCut));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FiberCut, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FiberCut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *arg1 = (struct FiberCut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FiberCut",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberCut, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FiberCut" "', argument " "1"" of type '" "struct FiberCut *""'"); 
  }
  arg1 = (struct FiberCut *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_func_type_fnd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  union func_type *arg1 = (union func_type *) 0 ;
  double (*arg2)(double *,void *) = (double (*)(double *,void *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:func_type_fnd_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_func_type, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "func_type_fnd_set" "', argument " "1"" of type '" "union func_type *""'"); 
  }
  arg1 = (union func_type *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "func_type_fnd_set" "', argument " "2"" of type '" "double (*)(double *,void *)""'"); 
    }
  }
  if (arg1) (arg1)->fnd = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_func_type_fnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  union func_type *arg1 = (union func_type *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double (*result)(double *,void *) = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:func_type_fnd_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_func_type, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "func_type_fnd_get" "', argument " "1"" of type '" "union func_type *""'"); 
  }
  arg1 = (union func_type *)(argp1);
  result = (double (*)(double *,void *)) ((arg1)->fnd);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_double_p_void__double);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_func_type_f2d_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  union func_type *arg1 = (union func_type *) 0 ;
  double (*arg2)(double,double,void *) = (double (*)(double,double,void *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:func_type_f2d_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_func_type, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "func_type_f2d_set" "', argument " "1"" of type '" "union func_type *""'"); 
  }
  arg1 = (union func_type *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_double_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "func_type_f2d_set" "', argument " "2"" of type '" "double (*)(double,double,void *)""'"); 
    }
  }
  if (arg1) (arg1)->f2d = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_func_type_f2d_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  union func_type *arg1 = (union func_type *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double (*result)(double,double,void *) = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:func_type_f2d_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_func_type, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "func_type_f2d_get" "', argument " "1"" of type '" "union func_type *""'"); 
  }
  arg1 = (union func_type *)(argp1);
  result = (double (*)(double,double,void *)) ((arg1)->f2d);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_double_double_p_void__double);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_func_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  union func_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_func_type")) SWIG_fail;
  result = (union func_type *)calloc(1, sizeof(union func_type));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_func_type, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_func_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  union func_type *arg1 = (union func_type *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_func_type",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_func_type, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_func_type" "', argument " "1"" of type '" "union func_type *""'"); 
  }
  arg1 = (union func_type *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_fiber_cut_init2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double (*arg1)(double,double,void *) = (double (*)(double,double,void *)) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  double arg4 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct FiberCut *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:fiber_cut_init2d",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_double_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fiber_cut_init2d" "', argument " "1"" of type '" "double (*)(double,double,void *)""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fiber_cut_init2d" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fiber_cut_init2d" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fiber_cut_init2d" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  result = (struct FiberCut *)fiber_cut_init2d(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FiberCut, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_cut_2darray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double (*arg1)(double,double,void *) = (double (*)(double,double,void *)) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  struct FiberCut **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:fiber_cut_2darray",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_double_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fiber_cut_2darray" "', argument " "1"" of type '" "double (*)(double,double,void *)""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fiber_cut_2darray" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fiber_cut_2darray" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fiber_cut_2darray" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "fiber_cut_2darray" "', argument " "5"" of type '" "double const *""'"); 
  }
  arg5 = (double *)(argp5);
  result = (struct FiberCut **)fiber_cut_2darray(arg1,arg2,arg3,arg4,(double const *)arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_FiberCut, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_cut_ndarray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double (*arg1)(double *,void *) = (double (*)(double *,void *)) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  double **arg6 = (double **) 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  struct FiberCut **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:fiber_cut_ndarray",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_p_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fiber_cut_ndarray" "', argument " "1"" of type '" "double (*)(double *,void *)""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fiber_cut_ndarray" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fiber_cut_ndarray" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fiber_cut_ndarray" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fiber_cut_ndarray" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "fiber_cut_ndarray" "', argument " "6"" of type '" "double **""'"); 
  }
  arg6 = (double **)(argp6);
  result = (struct FiberCut **)fiber_cut_ndarray(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_FiberCut, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_cut_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FiberCut *arg1 = (struct FiberCut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:fiber_cut_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FiberCut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fiber_cut_free" "', argument " "1"" of type '" "struct FiberCut *""'"); 
  }
  arg1 = (struct FiberCut *)(argp1);
  fiber_cut_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_cut_array_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct FiberCut **arg2 = (struct FiberCut **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fiber_cut_array_free",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fiber_cut_array_free" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_FiberCut, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fiber_cut_array_free" "', argument " "2"" of type '" "struct FiberCut **""'"); 
  }
  arg2 = (struct FiberCut **)(argp2);
  fiber_cut_array_free(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


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


SWIGINTERN PyObject *_wrap_fwrap_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  char *arg2 = (char *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Fwrap *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fwrap_create",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fwrap_create" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fwrap_create" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  result = (struct Fwrap *)fwrap_create(arg1,(char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fwrap, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_get_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:fwrap_get_type",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_get_type" "', argument " "1"" of type '" "struct Fwrap const *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  result = (int)fwrap_get_type((struct Fwrap const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_set_f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  double (*arg2)(double const *,void *) = (double (*)(double const *,void *)) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:fwrap_set_f",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_set_f" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fwrap_set_f" "', argument " "2"" of type '" "double (*)(double const *,void *)""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fwrap_set_f" "', argument " "3"" of type '" "void *""'"); 
  }
  fwrap_set_f(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_set_findex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  double (*arg2)(size_t const *,void *) = (double (*)(size_t const *,void *)) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:fwrap_set_findex",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_set_findex" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__unsigned_long_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fwrap_set_findex" "', argument " "2"" of type '" "double (*)(size_t const *,void *)""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fwrap_set_findex" "', argument " "3"" of type '" "void *""'"); 
  }
  fwrap_set_findex(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_set_fvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  int (*arg2)(size_t,double const *,double *,void *) = (int (*)(size_t,double const *,double *,void *)) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:fwrap_set_fvec",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_set_fvec" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_unsigned_long_p_q_const__double_p_double_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fwrap_set_fvec" "', argument " "2"" of type '" "int (*)(size_t,double const *,double *,void *)""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fwrap_set_fvec" "', argument " "3"" of type '" "void *""'"); 
  }
  fwrap_set_fvec(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_set_mofvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  int (*arg2)(size_t,size_t,double const *,double *,void *) = (int (*)(size_t,size_t,double const *,double *,void *)) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:fwrap_set_mofvec",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_set_mofvec" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fwrap_set_mofvec" "', argument " "2"" of type '" "int (*)(size_t,size_t,double const *,double *,void *)""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fwrap_set_mofvec" "', argument " "3"" of type '" "void *""'"); 
  }
  fwrap_set_mofvec(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_set_which_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fwrap_set_which_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_set_which_eval" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fwrap_set_which_eval" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  fwrap_set_which_eval(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_get_which_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:fwrap_get_which_eval",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_get_which_eval" "', argument " "1"" of type '" "struct Fwrap const *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  result = (size_t)fwrap_get_which_eval((struct Fwrap const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_set_num_funcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fwrap_set_num_funcs",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_set_num_funcs" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fwrap_set_num_funcs" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  fwrap_set_num_funcs(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_set_func_array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  size_t arg2 ;
  int (*arg3)(size_t,double const *,double *,void *) = (int (*)(size_t,double const *,double *,void *)) 0 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:fwrap_set_func_array",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_set_func_array" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fwrap_set_func_array" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  {
    int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_unsigned_long_p_q_const__double_p_double_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fwrap_set_func_array" "', argument " "3"" of type '" "int (*)(size_t,double const *,double *,void *)""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fwrap_set_func_array" "', argument " "4"" of type '" "void *""'"); 
  }
  fwrap_set_func_array(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:fwrap_destroy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_destroy" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  fwrap_destroy(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  void *arg2 = (void *) 0 ;
  double *arg3 = (double *) 0 ;
  void *arg4 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:fwrap_eval",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fwrap_eval" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fwrap_eval" "', argument " "2"" of type '" "void const *""'"); 
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fwrap_eval" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fwrap_eval" "', argument " "4"" of type '" "void *""'"); 
  }
  result = (int)fwrap_eval(arg1,(void const *)arg2,arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_initialize_fiber_approx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:fwrap_initialize_fiber_approx",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_initialize_fiber_approx" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fwrap_initialize_fiber_approx" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fwrap_initialize_fiber_approx" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  fwrap_initialize_fiber_approx(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_add_fiber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  size_t arg5 ;
  void *arg6 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int res6 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:fwrap_add_fiber",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_add_fiber" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fwrap_add_fiber" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fwrap_add_fiber" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fwrap_add_fiber" "', argument " "4"" of type '" "void const *""'"); 
  }
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fwrap_add_fiber" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "fwrap_add_fiber" "', argument " "6"" of type '" "void const *""'"); 
  }
  fwrap_add_fiber(arg1,arg2,arg3,(void const *)arg4,arg5,(void const *)arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_set_which_fiber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fwrap_set_which_fiber",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_set_which_fiber" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fwrap_set_which_fiber" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  fwrap_set_which_fiber(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_clean_fiber_approx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:fwrap_clean_fiber_approx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fwrap_clean_fiber_approx" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  fwrap_clean_fiber_approx(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fwrap_eval_fiber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  void *arg2 = (void *) 0 ;
  double *arg3 = (double *) 0 ;
  void *arg4 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:fwrap_eval_fiber",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fwrap_eval_fiber" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fwrap_eval_fiber" "', argument " "2"" of type '" "void const *""'"); 
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fwrap_eval_fiber" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fwrap_eval_fiber" "', argument " "4"" of type '" "void *""'"); 
  }
  result = (int)fwrap_eval_fiber(arg1,(void const *)arg2,arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_init_hermite_poly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":init_hermite_poly")) SWIG_fail;
  result = (struct OrthPoly *)init_hermite_poly();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hermite_integrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:hermite_integrate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hermite_integrate" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (double)hermite_integrate((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int Swig_var_lpolycoeffs_set(PyObject *_val SWIGUNUSED) {
  SWIG_Error(SWIG_AttributeError,"Variable lpolycoeffs is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_lpolycoeffs_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(lpolycoeffs), SWIGTYPE_p_double,  0 );
  return pyobj;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_aopts_alloc_adapt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  struct LinElemExpAopts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:lin_elem_exp_aopts_alloc_adapt",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "lin_elem_exp_aopts_alloc_adapt" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_aopts_alloc_adapt" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lin_elem_exp_aopts_alloc_adapt" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "lin_elem_exp_aopts_alloc_adapt" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "lin_elem_exp_aopts_alloc_adapt" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "lin_elem_exp_aopts_alloc_adapt" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = (double)(val6);
  result = (struct LinElemExpAopts *)lin_elem_exp_aopts_alloc_adapt(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_aopts_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts *arg1 = (struct LinElemExpAopts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_aopts_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_aopts_free" "', argument " "1"" of type '" "struct LinElemExpAopts *""'"); 
  }
  arg1 = (struct LinElemExpAopts *)(argp1);
  lin_elem_exp_aopts_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_aopts_free_deep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts **arg1 = (struct LinElemExpAopts **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_aopts_free_deep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_aopts_free_deep" "', argument " "1"" of type '" "struct LinElemExpAopts **""'"); 
  }
  arg1 = (struct LinElemExpAopts **)(argp1);
  lin_elem_exp_aopts_free_deep(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_aopts_get_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts *arg1 = (struct LinElemExpAopts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_aopts_get_lb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_aopts_get_lb" "', argument " "1"" of type '" "struct LinElemExpAopts const *""'"); 
  }
  arg1 = (struct LinElemExpAopts *)(argp1);
  result = (double)lin_elem_exp_aopts_get_lb((struct LinElemExpAopts const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_aopts_get_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts *arg1 = (struct LinElemExpAopts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_aopts_get_ub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_aopts_get_ub" "', argument " "1"" of type '" "struct LinElemExpAopts const *""'"); 
  }
  arg1 = (struct LinElemExpAopts *)(argp1);
  result = (double)lin_elem_exp_aopts_get_ub((struct LinElemExpAopts const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_aopts_set_nodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts *arg1 = (struct LinElemExpAopts *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_aopts_set_nodes",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_aopts_set_nodes" "', argument " "1"" of type '" "struct LinElemExpAopts *""'"); 
  }
  arg1 = (struct LinElemExpAopts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_aopts_set_nodes" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lin_elem_exp_aopts_set_nodes" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  lin_elem_exp_aopts_set_nodes(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_aopts_set_nodes_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts *arg1 = (struct LinElemExpAopts *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_aopts_set_nodes_copy",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_aopts_set_nodes_copy" "', argument " "1"" of type '" "struct LinElemExpAopts *""'"); 
  }
  arg1 = (struct LinElemExpAopts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_aopts_set_nodes_copy" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lin_elem_exp_aopts_set_nodes_copy" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  lin_elem_exp_aopts_set_nodes_copy(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_aopts_set_adapt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts *arg1 = (struct LinElemExpAopts *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_aopts_set_adapt",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_aopts_set_adapt" "', argument " "1"" of type '" "struct LinElemExpAopts *""'"); 
  }
  arg1 = (struct LinElemExpAopts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_aopts_set_adapt" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lin_elem_exp_aopts_set_adapt" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  lin_elem_exp_aopts_set_adapt(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_aopts_set_delta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts *arg1 = (struct LinElemExpAopts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_aopts_set_delta",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_aopts_set_delta" "', argument " "1"" of type '" "struct LinElemExpAopts *""'"); 
  }
  arg1 = (struct LinElemExpAopts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_aopts_set_delta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  lin_elem_exp_aopts_set_delta(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_aopts_set_hmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts *arg1 = (struct LinElemExpAopts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_aopts_set_hmin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_aopts_set_hmin" "', argument " "1"" of type '" "struct LinElemExpAopts *""'"); 
  }
  arg1 = (struct LinElemExpAopts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_aopts_set_hmin" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  lin_elem_exp_aopts_set_hmin(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_aopts_get_num_nodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts *arg1 = (struct LinElemExpAopts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_aopts_get_num_nodes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_aopts_get_num_nodes" "', argument " "1"" of type '" "struct LinElemExpAopts const *""'"); 
  }
  arg1 = (struct LinElemExpAopts *)(argp1);
  result = (size_t)lin_elem_exp_aopts_get_num_nodes((struct LinElemExpAopts const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_aopts_get_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts *arg1 = (struct LinElemExpAopts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_aopts_get_nparams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_aopts_get_nparams" "', argument " "1"" of type '" "struct LinElemExpAopts const *""'"); 
  }
  arg1 = (struct LinElemExpAopts *)(argp1);
  result = (size_t)lin_elem_exp_aopts_get_nparams((struct LinElemExpAopts const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_aopts_set_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts *arg1 = (struct LinElemExpAopts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_aopts_set_nparams",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_aopts_set_nparams" "', argument " "1"" of type '" "struct LinElemExpAopts *""'"); 
  }
  arg1 = (struct LinElemExpAopts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_aopts_set_nparams" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  lin_elem_exp_aopts_set_nparams(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinElemExp_num_nodes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinElemExp_num_nodes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinElemExp_num_nodes_set" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinElemExp_num_nodes_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->num_nodes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinElemExp_num_nodes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinElemExp_num_nodes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinElemExp_num_nodes_get" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (size_t) ((arg1)->num_nodes);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinElemExp_nodes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinElemExp_nodes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinElemExp_nodes_set" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinElemExp_nodes_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->nodes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinElemExp_nodes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinElemExp_nodes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinElemExp_nodes_get" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (double *) ((arg1)->nodes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinElemExp_coeff_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinElemExp_coeff_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinElemExp_coeff_set" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinElemExp_coeff_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->coeff = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinElemExp_coeff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinElemExp_coeff_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinElemExp_coeff_get" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (double *) ((arg1)->coeff);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinElemExp_diff_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinElemExp_diff_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinElemExp_diff_set" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinElemExp_diff_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->diff = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinElemExp_diff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinElemExp_diff_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinElemExp_diff_get" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (double *) ((arg1)->diff);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinElemExp_inner_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinElemExp_inner_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinElemExp_inner_set" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinElemExp_inner_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->inner = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinElemExp_inner_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinElemExp_inner_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinElemExp_inner_get" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (double *) ((arg1)->inner);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinElemExp_Lp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinElemExp_Lp_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinElemExp_Lp_set" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinElemExp_Lp_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->Lp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinElemExp_Lp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinElemExp_Lp_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinElemExp_Lp_get" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (double *) ((arg1)->Lp);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinElemExp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LinElemExp")) SWIG_fail;
  result = (struct LinElemExp *)calloc(1, sizeof(struct LinElemExp));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LinElemExp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LinElemExp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinElemExp" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_lin_elem_exp_get_num_nodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_get_num_nodes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_get_num_nodes" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (size_t)lin_elem_exp_get_num_nodes((struct LinElemExp const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_get_num_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_get_num_params",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_get_num_params" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (size_t)lin_elem_exp_get_num_params((struct LinElemExp const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":lin_elem_exp_alloc")) SWIG_fail;
  result = (struct LinElemExp *)lin_elem_exp_alloc();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_copy" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (struct LinElemExp *)lin_elem_exp_copy(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_free" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  lin_elem_exp_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_init",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "lin_elem_exp_init" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_init" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lin_elem_exp_init" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (struct LinElemExp *)lin_elem_exp_init(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_create_with_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts *arg1 = (struct LinElemExpAopts *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_create_with_params",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_create_with_params" "', argument " "1"" of type '" "struct LinElemExpAopts *""'"); 
  }
  arg1 = (struct LinElemExpAopts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_create_with_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lin_elem_exp_create_with_params" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (struct LinElemExp *)lin_elem_exp_create_with_params(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_update_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_update_params",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_update_params" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_update_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lin_elem_exp_update_params" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (int)lin_elem_exp_update_params(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_get_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_get_params",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_get_params" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_get_params" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (size_t)lin_elem_exp_get_params((struct LinElemExp const *)arg1,arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_get_params_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_get_params_ref",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_get_params_ref" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_get_params_ref" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (double *)lin_elem_exp_get_params_ref((struct LinElemExp const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_serialize_lin_elem_exp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct LinElemExp *arg2 = (struct LinElemExp *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:serialize_lin_elem_exp",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "serialize_lin_elem_exp" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "serialize_lin_elem_exp" "', argument " "2"" of type '" "struct LinElemExp *""'"); 
  }
  arg2 = (struct LinElemExp *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "serialize_lin_elem_exp" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (unsigned char *)serialize_lin_elem_exp(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_deserialize_lin_elem_exp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct LinElemExp **arg2 = (struct LinElemExp **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:deserialize_lin_elem_exp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deserialize_lin_elem_exp" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "deserialize_lin_elem_exp" "', argument " "2"" of type '" "struct LinElemExp **""'"); 
  }
  arg2 = (struct LinElemExp **)(argp2);
  result = (unsigned char *)deserialize_lin_elem_exp(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_eval" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_eval" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)lin_elem_exp_eval((struct LinElemExp const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_deriv_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_deriv_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_deriv_eval" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_deriv_eval" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)lin_elem_exp_deriv_eval((struct LinElemExp const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_evalN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:lin_elem_exp_evalN",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_evalN" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_evalN" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lin_elem_exp_evalN" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "lin_elem_exp_evalN" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "lin_elem_exp_evalN" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "lin_elem_exp_evalN" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  lin_elem_exp_evalN((struct LinElemExp const *)arg1,arg2,(double const *)arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_get_nodal_val(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_get_nodal_val",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_get_nodal_val" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_get_nodal_val" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double)lin_elem_exp_get_nodal_val((struct LinElemExp const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_deriv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_deriv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_deriv" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (struct LinElemExp *)lin_elem_exp_deriv((struct LinElemExp const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_dderiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_dderiv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_dderiv" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (struct LinElemExp *)lin_elem_exp_dderiv((struct LinElemExp const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_dderiv_periodic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_dderiv_periodic",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_dderiv_periodic" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (struct LinElemExp *)lin_elem_exp_dderiv_periodic(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_param_grad_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:lin_elem_exp_param_grad_eval",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_param_grad_eval" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_param_grad_eval" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lin_elem_exp_param_grad_eval" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "lin_elem_exp_param_grad_eval" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (int)lin_elem_exp_param_grad_eval(arg1,arg2,(double const *)arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_param_grad_eval2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  double arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_param_grad_eval2",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_param_grad_eval2" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_param_grad_eval2" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lin_elem_exp_param_grad_eval2" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (double)lin_elem_exp_param_grad_eval2(arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_squared_norm_param_grad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  double arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_squared_norm_param_grad",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_squared_norm_param_grad" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_squared_norm_param_grad" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lin_elem_exp_squared_norm_param_grad" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (int)lin_elem_exp_squared_norm_param_grad((struct LinElemExp const *)arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_integrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_integrate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_integrate" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (double)lin_elem_exp_integrate((struct LinElemExp const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_integrate_weighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_integrate_weighted",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_integrate_weighted" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (double)lin_elem_exp_integrate_weighted((struct LinElemExp const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_inner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  struct LinElemExp *arg2 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_inner",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_inner" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_inner" "', argument " "2"" of type '" "struct LinElemExp const *""'"); 
  }
  arg2 = (struct LinElemExp *)(argp2);
  result = (double)lin_elem_exp_inner((struct LinElemExp const *)arg1,(struct LinElemExp const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_axpy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct LinElemExp *arg2 = (struct LinElemExp *) 0 ;
  struct LinElemExp *arg3 = (struct LinElemExp *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_axpy",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "lin_elem_exp_axpy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_axpy" "', argument " "2"" of type '" "struct LinElemExp const *""'"); 
  }
  arg2 = (struct LinElemExp *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lin_elem_exp_axpy" "', argument " "3"" of type '" "struct LinElemExp *""'"); 
  }
  arg3 = (struct LinElemExp *)(argp3);
  result = (int)lin_elem_exp_axpy(arg1,(struct LinElemExp const *)arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_prod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  struct LinElemExp *arg2 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_prod",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_prod" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_prod" "', argument " "2"" of type '" "struct LinElemExp const *""'"); 
  }
  arg2 = (struct LinElemExp *)(argp2);
  result = (struct LinElemExp *)lin_elem_exp_prod((struct LinElemExp const *)arg1,(struct LinElemExp const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_norm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_norm" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (double)lin_elem_exp_norm((struct LinElemExp const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_max",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_max" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_max" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (double)lin_elem_exp_max((struct LinElemExp const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_min",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_min" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_min" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (double)lin_elem_exp_min((struct LinElemExp const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_absmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:lin_elem_exp_absmax",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_absmax" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_absmax" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lin_elem_exp_absmax" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "lin_elem_exp_absmax" "', argument " "4"" of type '" "void *""'"); 
  }
  result = (double)lin_elem_exp_absmax((struct LinElemExp const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_err_est(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  double *arg2 = (double *) 0 ;
  short arg3 ;
  short arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:lin_elem_exp_err_est",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_err_est" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_err_est" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_short(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lin_elem_exp_err_est" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = (short)(val3);
  ecode4 = SWIG_AsVal_short(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "lin_elem_exp_err_est" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = (short)(val4);
  result = (double)lin_elem_exp_err_est(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_adapt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  struct LinElemXY **arg8 = (struct LinElemXY **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:lin_elem_adapt",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_adapt" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_adapt" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lin_elem_adapt" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "lin_elem_adapt" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "lin_elem_adapt" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "lin_elem_adapt" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = (double)(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "lin_elem_adapt" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = (double)(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_p_LinElemXY, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "lin_elem_adapt" "', argument " "8"" of type '" "struct LinElemXY **""'"); 
  }
  arg8 = (struct LinElemXY **)(argp8);
  lin_elem_adapt(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_xy_get_x(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemXY *arg1 = (struct LinElemXY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_xy_get_x",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemXY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_xy_get_x" "', argument " "1"" of type '" "struct LinElemXY *""'"); 
  }
  arg1 = (struct LinElemXY *)(argp1);
  result = (double)lin_elem_xy_get_x(arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_xy_get_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemXY *arg1 = (struct LinElemXY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_xy_get_y",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemXY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_xy_get_y" "', argument " "1"" of type '" "struct LinElemXY *""'"); 
  }
  arg1 = (struct LinElemXY *)(argp1);
  result = (double)lin_elem_xy_get_y(arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_xy_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemXY *arg1 = (struct LinElemXY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct LinElemXY *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_xy_next",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemXY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_xy_next" "', argument " "1"" of type '" "struct LinElemXY *""'"); 
  }
  arg1 = (struct LinElemXY *)(argp1);
  result = (struct LinElemXY *)lin_elem_xy_next(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemXY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_xy_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemXY *arg1 = (struct LinElemXY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_xy_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemXY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_xy_free" "', argument " "1"" of type '" "struct LinElemXY *""'"); 
  }
  arg1 = (struct LinElemXY *)(argp1);
  lin_elem_xy_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_approx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts *arg1 = (struct LinElemExpAopts *) 0 ;
  struct Fwrap *arg2 = (struct Fwrap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_approx",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_approx" "', argument " "1"" of type '" "struct LinElemExpAopts *""'"); 
  }
  arg1 = (struct LinElemExpAopts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_approx" "', argument " "2"" of type '" "struct Fwrap *""'"); 
  }
  arg2 = (struct Fwrap *)(argp2);
  result = (struct LinElemExp *)lin_elem_exp_approx(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct LinElemExp *arg2 = (struct LinElemExp *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_scale",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "lin_elem_exp_scale" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_scale" "', argument " "2"" of type '" "struct LinElemExp *""'"); 
  }
  arg2 = (struct LinElemExp *)(argp2);
  lin_elem_exp_scale(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_flip_sign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_flip_sign",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_flip_sign" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  lin_elem_exp_flip_sign(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_orth_basis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct LinElemExp **arg2 = (struct LinElemExp **) 0 ;
  struct LinElemExpAopts *arg3 = (struct LinElemExpAopts *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_orth_basis",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "lin_elem_exp_orth_basis" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_orth_basis" "', argument " "2"" of type '" "struct LinElemExp **""'"); 
  }
  arg2 = (struct LinElemExp **)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lin_elem_exp_orth_basis" "', argument " "3"" of type '" "struct LinElemExpAopts *""'"); 
  }
  arg3 = (struct LinElemExpAopts *)(argp3);
  lin_elem_exp_orth_basis(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_zero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExpAopts *arg1 = (struct LinElemExpAopts *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_zero",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_zero" "', argument " "1"" of type '" "struct LinElemExpAopts const *""'"); 
  }
  arg1 = (struct LinElemExpAopts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_zero" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  result = (struct LinElemExp *)lin_elem_exp_zero((struct LinElemExpAopts const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_constant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct LinElemExpAopts *arg2 = (struct LinElemExpAopts *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lin_elem_exp_constant",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "lin_elem_exp_constant" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_constant" "', argument " "2"" of type '" "struct LinElemExpAopts const *""'"); 
  }
  arg2 = (struct LinElemExpAopts *)(argp2);
  result = (struct LinElemExp *)lin_elem_exp_constant(arg1,(struct LinElemExpAopts const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_linear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  struct LinElemExpAopts *arg3 = (struct LinElemExpAopts *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_linear",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "lin_elem_exp_linear" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_linear" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lin_elem_exp_linear" "', argument " "3"" of type '" "struct LinElemExpAopts const *""'"); 
  }
  arg3 = (struct LinElemExpAopts *)(argp3);
  result = (struct LinElemExp *)lin_elem_exp_linear(arg1,arg2,(struct LinElemExpAopts const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_linear_update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_linear_update",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_linear_update" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_linear_update" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lin_elem_exp_linear_update" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  result = (int)lin_elem_exp_linear_update(arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_quadratic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  struct LinElemExpAopts *arg3 = (struct LinElemExpAopts *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_quadratic",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "lin_elem_exp_quadratic" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lin_elem_exp_quadratic" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lin_elem_exp_quadratic" "', argument " "3"" of type '" "struct LinElemExpAopts const *""'"); 
  }
  arg3 = (struct LinElemExpAopts *)(argp3);
  result = (struct LinElemExp *)lin_elem_exp_quadratic(arg1,arg2,(struct LinElemExpAopts const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_get_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_get_lb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_get_lb" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (double)lin_elem_exp_get_lb(arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_get_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_get_ub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_get_ub" "', argument " "1"" of type '" "struct LinElemExp *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  result = (double)lin_elem_exp_get_ub(arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_onezero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  struct LinElemExpAopts *arg3 = (struct LinElemExpAopts *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_onezero",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "lin_elem_exp_onezero" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_onezero" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_LinElemExpAopts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lin_elem_exp_onezero" "', argument " "3"" of type '" "struct LinElemExpAopts *""'"); 
  }
  arg3 = (struct LinElemExpAopts *)(argp3);
  result = (struct LinElemExp *)lin_elem_exp_onezero(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_lin_elem_exp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  size_t arg2 ;
  void *arg3 = (void *) 0 ;
  FILE *arg4 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:print_lin_elem_exp",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_lin_elem_exp" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "print_lin_elem_exp" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "print_lin_elem_exp" "', argument " "3"" of type '" "void *""'"); 
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "print_lin_elem_exp" "', argument " "4"" of type '" "FILE *""'"); 
  }
  arg4 = (FILE *)(argp4);
  print_lin_elem_exp((struct LinElemExp const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_savetxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinElemExp *arg1 = (struct LinElemExp *) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:lin_elem_exp_savetxt",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinElemExp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_savetxt" "', argument " "1"" of type '" "struct LinElemExp const *""'"); 
  }
  arg1 = (struct LinElemExp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lin_elem_exp_savetxt" "', argument " "2"" of type '" "FILE *""'"); 
  }
  arg2 = (FILE *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lin_elem_exp_savetxt" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  lin_elem_exp_savetxt((struct LinElemExp const *)arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lin_elem_exp_loadtxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FILE *arg1 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct LinElemExp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:lin_elem_exp_loadtxt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lin_elem_exp_loadtxt" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = (FILE *)(argp1);
  result = (struct LinElemExp *)lin_elem_exp_loadtxt(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinElemExp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


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


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


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


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


SWIGINTERN PyObject *_wrap_kernel_gaussian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct Kernel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:kernel_gaussian",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "kernel_gaussian" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_gaussian" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "kernel_gaussian" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  result = (struct Kernel *)kernel_gaussian(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Kernel, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Kernel *arg1 = (struct Kernel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Kernel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_free" "', argument " "1"" of type '" "struct Kernel *""'"); 
  }
  arg1 = (struct Kernel *)(argp1);
  kernel_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_approx_opts_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelApproxOpts *arg1 = (struct KernelApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_approx_opts_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_approx_opts_free" "', argument " "1"" of type '" "struct KernelApproxOpts *""'"); 
  }
  arg1 = (struct KernelApproxOpts *)(argp1);
  kernel_approx_opts_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_approx_opts_gauss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double arg3 ;
  double arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct KernelApproxOpts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:kernel_approx_opts_gauss",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "kernel_approx_opts_gauss" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  {
    if (!PyList_Check(obj1)) {
      PyErr_SetString(PyExc_ValueError,"Expecting a list");
      return NULL;
    }
    int size = PyList_Size(obj1);
    arg2 = (double *) malloc(size * sizeof(double));
    for (int i = 0; i < size; i++){
      PyObject *s = PyList_GetItem(obj1,i);
      if (!PyFloat_Check(s)) {
        free(arg2);
        PyErr_SetString(PyExc_ValueError, "List items must be floating point values");
        return NULL;
      }
      arg2[i] = PyFloat_AsDouble(s);
    }
    
    /* printf("size = %d\n",size); */
    /* printf("list_elem = "); */
    /* for (int ii = 0; ii < size; ii++){ */
    /*   printf("arg2[%d] = %G\n",ii,arg2[ii]); */
    /* } */
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "kernel_approx_opts_gauss" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "kernel_approx_opts_gauss" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  result = (struct KernelApproxOpts *)kernel_approx_opts_gauss(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  {
    if (arg2) free(arg2);
  }
  return resultobj;
fail:
  {
    if (arg2) free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_approx_opts_set_center_adapt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelApproxOpts *arg1 = (struct KernelApproxOpts *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:kernel_approx_opts_set_center_adapt",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_approx_opts_set_center_adapt" "', argument " "1"" of type '" "struct KernelApproxOpts *""'"); 
  }
  arg1 = (struct KernelApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_approx_opts_set_center_adapt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  kernel_approx_opts_set_center_adapt(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_approx_opts_linear_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelApproxOpts *arg1 = (struct KernelApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_approx_opts_linear_p",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_approx_opts_linear_p" "', argument " "1"" of type '" "struct KernelApproxOpts const *""'"); 
  }
  arg1 = (struct KernelApproxOpts *)(argp1);
  result = (int)kernel_approx_opts_linear_p((struct KernelApproxOpts const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_approx_opts_get_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelApproxOpts *arg1 = (struct KernelApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_approx_opts_get_nparams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_approx_opts_get_nparams" "', argument " "1"" of type '" "struct KernelApproxOpts *""'"); 
  }
  arg1 = (struct KernelApproxOpts *)(argp1);
  result = (size_t)kernel_approx_opts_get_nparams(arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_approx_opts_set_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelApproxOpts *arg1 = (struct KernelApproxOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:kernel_approx_opts_set_nparams",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_approx_opts_set_nparams" "', argument " "1"" of type '" "struct KernelApproxOpts *""'"); 
  }
  arg1 = (struct KernelApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_approx_opts_set_nparams" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  kernel_approx_opts_set_nparams(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_approx_opts_set_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelApproxOpts *arg1 = (struct KernelApproxOpts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:kernel_approx_opts_set_lb",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_approx_opts_set_lb" "', argument " "1"" of type '" "struct KernelApproxOpts *""'"); 
  }
  arg1 = (struct KernelApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_approx_opts_set_lb" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  kernel_approx_opts_set_lb(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_approx_opts_get_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelApproxOpts *arg1 = (struct KernelApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_approx_opts_get_lb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_approx_opts_get_lb" "', argument " "1"" of type '" "struct KernelApproxOpts *""'"); 
  }
  arg1 = (struct KernelApproxOpts *)(argp1);
  result = (double)kernel_approx_opts_get_lb(arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_approx_opts_set_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelApproxOpts *arg1 = (struct KernelApproxOpts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:kernel_approx_opts_set_ub",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_approx_opts_set_ub" "', argument " "1"" of type '" "struct KernelApproxOpts *""'"); 
  }
  arg1 = (struct KernelApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_approx_opts_set_ub" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  kernel_approx_opts_set_ub(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_approx_opts_get_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelApproxOpts *arg1 = (struct KernelApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_approx_opts_get_ub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_approx_opts_get_ub" "', argument " "1"" of type '" "struct KernelApproxOpts *""'"); 
  }
  arg1 = (struct KernelApproxOpts *)(argp1);
  result = (double)kernel_approx_opts_get_ub(arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct KernelExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_alloc",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "kernel_expansion_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct KernelExpansion *)kernel_expansion_alloc(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KernelExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_get_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_get_lb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_get_lb" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  result = (double)kernel_expansion_get_lb((struct KernelExpansion const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_get_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_get_ub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_get_ub" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  result = (double)kernel_expansion_get_ub((struct KernelExpansion const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_serialize_kernel_expansion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct KernelExpansion *arg2 = (struct KernelExpansion *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:serialize_kernel_expansion",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "serialize_kernel_expansion" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "serialize_kernel_expansion" "', argument " "2"" of type '" "struct KernelExpansion *""'"); 
  }
  arg2 = (struct KernelExpansion *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "serialize_kernel_expansion" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (unsigned char *)serialize_kernel_expansion(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_deserialize_kernel_expansion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct KernelExpansion **arg2 = (struct KernelExpansion **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:deserialize_kernel_expansion",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deserialize_kernel_expansion" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "deserialize_kernel_expansion" "', argument " "2"" of type '" "struct KernelExpansion **""'"); 
  }
  arg2 = (struct KernelExpansion **)(argp2);
  result = (unsigned char *)deserialize_kernel_expansion(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct KernelExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_copy" "', argument " "1"" of type '" "struct KernelExpansion *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  result = (struct KernelExpansion *)kernel_expansion_copy(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KernelExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_free" "', argument " "1"" of type '" "struct KernelExpansion *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  kernel_expansion_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_set_bounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:kernel_expansion_set_bounds",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_set_bounds" "', argument " "1"" of type '" "struct KernelExpansion *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_expansion_set_bounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "kernel_expansion_set_bounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  kernel_expansion_set_bounds(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_get_nkernels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_get_nkernels",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_get_nkernels" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  result = (size_t)kernel_expansion_get_nkernels((struct KernelExpansion const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_add_kernel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  double arg2 ;
  struct Kernel *arg3 = (struct Kernel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:kernel_expansion_add_kernel",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_add_kernel" "', argument " "1"" of type '" "struct KernelExpansion *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_expansion_add_kernel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Kernel, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kernel_expansion_add_kernel" "', argument " "3"" of type '" "struct Kernel *""'"); 
  }
  arg3 = (struct Kernel *)(argp3);
  kernel_expansion_add_kernel(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelApproxOpts *arg1 = (struct KernelApproxOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct KernelExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_init" "', argument " "1"" of type '" "struct KernelApproxOpts const *""'"); 
  }
  arg1 = (struct KernelApproxOpts *)(argp1);
  result = (struct KernelExpansion *)kernel_expansion_init((struct KernelApproxOpts const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KernelExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_update_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:kernel_expansion_update_params",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_update_params" "', argument " "1"" of type '" "struct KernelExpansion *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_expansion_update_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kernel_expansion_update_params" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (int)kernel_expansion_update_params(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_create_with_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelApproxOpts *arg1 = (struct KernelApproxOpts *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct KernelExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:kernel_expansion_create_with_params",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_create_with_params" "', argument " "1"" of type '" "struct KernelApproxOpts *""'"); 
  }
  arg1 = (struct KernelApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_expansion_create_with_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kernel_expansion_create_with_params" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (struct KernelExpansion *)kernel_expansion_create_with_params(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KernelExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_zero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelApproxOpts *arg1 = (struct KernelApproxOpts *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct KernelExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:kernel_expansion_zero",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_zero" "', argument " "1"" of type '" "struct KernelApproxOpts const *""'"); 
  }
  arg1 = (struct KernelApproxOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_expansion_zero" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  result = (struct KernelExpansion *)kernel_expansion_zero((struct KernelApproxOpts const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KernelExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_constant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct KernelApproxOpts *arg2 = (struct KernelApproxOpts *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct KernelExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:kernel_expansion_constant",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "kernel_expansion_constant" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kernel_expansion_constant" "', argument " "2"" of type '" "struct KernelApproxOpts const *""'"); 
  }
  arg2 = (struct KernelApproxOpts *)(argp2);
  result = (struct KernelExpansion *)kernel_expansion_constant(arg1,(struct KernelApproxOpts const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KernelExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_linear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  struct KernelApproxOpts *arg3 = (struct KernelApproxOpts *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct KernelExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:kernel_expansion_linear",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "kernel_expansion_linear" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_expansion_linear" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kernel_expansion_linear" "', argument " "3"" of type '" "struct KernelApproxOpts const *""'"); 
  }
  arg3 = (struct KernelApproxOpts *)(argp3);
  result = (struct KernelExpansion *)kernel_expansion_linear(arg1,arg2,(struct KernelApproxOpts const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KernelExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_linear_update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:kernel_expansion_linear_update",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_linear_update" "', argument " "1"" of type '" "struct KernelExpansion *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_expansion_linear_update" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "kernel_expansion_linear_update" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  result = (int)kernel_expansion_linear_update(arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_quadratic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  void *arg3 = (void *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct KernelExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:kernel_expansion_quadratic",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "kernel_expansion_quadratic" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_expansion_quadratic" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kernel_expansion_quadratic" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (struct KernelExpansion *)kernel_expansion_quadratic(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KernelExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:kernel_expansion_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_eval" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_expansion_eval" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)kernel_expansion_eval((struct KernelExpansion const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_evalN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:kernel_expansion_evalN",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_evalN" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_expansion_evalN" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kernel_expansion_evalN" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "kernel_expansion_evalN" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "kernel_expansion_evalN" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "kernel_expansion_evalN" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  kernel_expansion_evalN((struct KernelExpansion const *)arg1,arg2,(double const *)arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_deriv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct KernelExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_deriv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_deriv" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  result = (struct KernelExpansion *)kernel_expansion_deriv((struct KernelExpansion const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KernelExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_dderiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct KernelExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_dderiv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_dderiv" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  result = (struct KernelExpansion *)kernel_expansion_dderiv((struct KernelExpansion const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KernelExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_dderiv_periodic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct KernelExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_dderiv_periodic",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_dderiv_periodic" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  result = (struct KernelExpansion *)kernel_expansion_dderiv_periodic((struct KernelExpansion const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KernelExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_deriv_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:kernel_expansion_deriv_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_deriv_eval" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_expansion_deriv_eval" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)kernel_expansion_deriv_eval((struct KernelExpansion const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_axpy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct KernelExpansion *arg2 = (struct KernelExpansion *) 0 ;
  struct KernelExpansion *arg3 = (struct KernelExpansion *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:kernel_expansion_axpy",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "kernel_expansion_axpy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kernel_expansion_axpy" "', argument " "2"" of type '" "struct KernelExpansion *""'"); 
  }
  arg2 = (struct KernelExpansion *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kernel_expansion_axpy" "', argument " "3"" of type '" "struct KernelExpansion *""'"); 
  }
  arg3 = (struct KernelExpansion *)(argp3);
  result = (int)kernel_expansion_axpy(arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_integrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_integrate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_integrate" "', argument " "1"" of type '" "struct KernelExpansion *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  result = (double)kernel_expansion_integrate(arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_integrate_weighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_integrate_weighted",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_integrate_weighted" "', argument " "1"" of type '" "struct KernelExpansion *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  result = (double)kernel_expansion_integrate_weighted(arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_prod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  struct KernelExpansion *arg2 = (struct KernelExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct KernelExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:kernel_expansion_prod",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_prod" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kernel_expansion_prod" "', argument " "2"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg2 = (struct KernelExpansion *)(argp2);
  result = (struct KernelExpansion *)kernel_expansion_prod((struct KernelExpansion const *)arg1,(struct KernelExpansion const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KernelExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_inner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  struct KernelExpansion *arg2 = (struct KernelExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:kernel_expansion_inner",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_inner" "', argument " "1"" of type '" "struct KernelExpansion *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kernel_expansion_inner" "', argument " "2"" of type '" "struct KernelExpansion *""'"); 
  }
  arg2 = (struct KernelExpansion *)(argp2);
  result = (double)kernel_expansion_inner(arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct KernelExpansion *arg2 = (struct KernelExpansion *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:kernel_expansion_scale",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "kernel_expansion_scale" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kernel_expansion_scale" "', argument " "2"" of type '" "struct KernelExpansion *""'"); 
  }
  arg2 = (struct KernelExpansion *)(argp2);
  kernel_expansion_scale(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_flip_sign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_flip_sign",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_flip_sign" "', argument " "1"" of type '" "struct KernelExpansion *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  kernel_expansion_flip_sign(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_get_num_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_get_num_params",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_get_num_params" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  result = (size_t)kernel_expansion_get_num_params((struct KernelExpansion const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_get_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:kernel_expansion_get_params",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_get_params" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kernel_expansion_get_params" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (size_t)kernel_expansion_get_params((struct KernelExpansion const *)arg1,arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_get_params_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:kernel_expansion_get_params_ref",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_get_params_ref" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kernel_expansion_get_params_ref" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (double *)kernel_expansion_get_params_ref((struct KernelExpansion const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_orth_basis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct KernelExpansion **arg2 = (struct KernelExpansion **) 0 ;
  struct KernelApproxOpts *arg3 = (struct KernelApproxOpts *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:kernel_expansion_orth_basis",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "kernel_expansion_orth_basis" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kernel_expansion_orth_basis" "', argument " "2"" of type '" "struct KernelExpansion **""'"); 
  }
  arg2 = (struct KernelExpansion **)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_KernelApproxOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kernel_expansion_orth_basis" "', argument " "3"" of type '" "struct KernelApproxOpts *""'"); 
  }
  arg3 = (struct KernelApproxOpts *)(argp3);
  kernel_expansion_orth_basis(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_param_grad_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:kernel_expansion_param_grad_eval",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_param_grad_eval" "', argument " "1"" of type '" "struct KernelExpansion *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_expansion_param_grad_eval" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kernel_expansion_param_grad_eval" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "kernel_expansion_param_grad_eval" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (int)kernel_expansion_param_grad_eval(arg1,arg2,(double const *)arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_param_grad_eval2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  double arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:kernel_expansion_param_grad_eval2",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_param_grad_eval2" "', argument " "1"" of type '" "struct KernelExpansion *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_expansion_param_grad_eval2" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kernel_expansion_param_grad_eval2" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (double)kernel_expansion_param_grad_eval2(arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_squared_norm_param_grad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  double arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:kernel_expansion_squared_norm_param_grad",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_squared_norm_param_grad" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kernel_expansion_squared_norm_param_grad" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kernel_expansion_squared_norm_param_grad" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (int)kernel_expansion_squared_norm_param_grad((struct KernelExpansion const *)arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_kernel_expansion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  size_t arg2 ;
  void *arg3 = (void *) 0 ;
  FILE *arg4 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:print_kernel_expansion",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_kernel_expansion" "', argument " "1"" of type '" "struct KernelExpansion *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "print_kernel_expansion" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "print_kernel_expansion" "', argument " "3"" of type '" "void *""'"); 
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "print_kernel_expansion" "', argument " "4"" of type '" "FILE *""'"); 
  }
  arg4 = (FILE *)(argp4);
  print_kernel_expansion(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_absmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  double *arg2 = (double *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:kernel_expansion_absmax",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_absmax" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kernel_expansion_absmax" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kernel_expansion_absmax" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (double)kernel_expansion_absmax((struct KernelExpansion const *)arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_savetxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct KernelExpansion *arg1 = (struct KernelExpansion *) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:kernel_expansion_savetxt",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KernelExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_savetxt" "', argument " "1"" of type '" "struct KernelExpansion const *""'"); 
  }
  arg1 = (struct KernelExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kernel_expansion_savetxt" "', argument " "2"" of type '" "FILE *""'"); 
  }
  arg2 = (FILE *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "kernel_expansion_savetxt" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  kernel_expansion_savetxt((struct KernelExpansion const *)arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kernel_expansion_loadtxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FILE *arg1 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct KernelExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:kernel_expansion_loadtxt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kernel_expansion_loadtxt" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = (FILE *)(argp1);
  result = (struct KernelExpansion *)kernel_expansion_loadtxt(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KernelExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionMonitor_f_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionMonitor *arg1 = (struct FunctionMonitor *) 0 ;
  union ff *arg2 = (union ff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionMonitor_f_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionMonitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionMonitor_f_set" "', argument " "1"" of type '" "struct FunctionMonitor *""'"); 
  }
  arg1 = (struct FunctionMonitor *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ff, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionMonitor_f_set" "', argument " "2"" of type '" "union ff *""'"); 
  }
  arg2 = (union ff *)(argp2);
  if (arg1) (arg1)->f = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionMonitor_f_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionMonitor *arg1 = (struct FunctionMonitor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  union ff *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionMonitor_f_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionMonitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionMonitor_f_get" "', argument " "1"" of type '" "struct FunctionMonitor *""'"); 
  }
  arg1 = (struct FunctionMonitor *)(argp1);
  result = (union ff *)& ((arg1)->f);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ff, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionMonitor_ftype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionMonitor *arg1 = (struct FunctionMonitor *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionMonitor_ftype_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionMonitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionMonitor_ftype_set" "', argument " "1"" of type '" "struct FunctionMonitor *""'"); 
  }
  arg1 = (struct FunctionMonitor *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FunctionMonitor_ftype_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->ftype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionMonitor_ftype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionMonitor *arg1 = (struct FunctionMonitor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionMonitor_ftype_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionMonitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionMonitor_ftype_get" "', argument " "1"" of type '" "struct FunctionMonitor *""'"); 
  }
  arg1 = (struct FunctionMonitor *)(argp1);
  result = (int) ((arg1)->ftype);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionMonitor_dim_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionMonitor *arg1 = (struct FunctionMonitor *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionMonitor_dim_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionMonitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionMonitor_dim_set" "', argument " "1"" of type '" "struct FunctionMonitor *""'"); 
  }
  arg1 = (struct FunctionMonitor *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FunctionMonitor_dim_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->dim = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionMonitor_dim_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionMonitor *arg1 = (struct FunctionMonitor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionMonitor_dim_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionMonitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionMonitor_dim_get" "', argument " "1"" of type '" "struct FunctionMonitor *""'"); 
  }
  arg1 = (struct FunctionMonitor *)(argp1);
  result = (size_t) ((arg1)->dim);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionMonitor_args_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionMonitor *arg1 = (struct FunctionMonitor *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionMonitor_args_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionMonitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionMonitor_args_set" "', argument " "1"" of type '" "struct FunctionMonitor *""'"); 
  }
  arg1 = (struct FunctionMonitor *)(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionMonitor_args_set" "', argument " "2"" of type '" "void *""'"); 
  }
  if (arg1) (arg1)->args = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionMonitor_args_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionMonitor *arg1 = (struct FunctionMonitor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionMonitor_args_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionMonitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionMonitor_args_get" "', argument " "1"" of type '" "struct FunctionMonitor *""'"); 
  }
  arg1 = (struct FunctionMonitor *)(argp1);
  result = (void *) ((arg1)->args);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionMonitor_evals_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionMonitor *arg1 = (struct FunctionMonitor *) 0 ;
  struct HashtableCpair *arg2 = (struct HashtableCpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FunctionMonitor_evals_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionMonitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionMonitor_evals_set" "', argument " "1"" of type '" "struct FunctionMonitor *""'"); 
  }
  arg1 = (struct FunctionMonitor *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_HashtableCpair, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionMonitor_evals_set" "', argument " "2"" of type '" "struct HashtableCpair *""'"); 
  }
  arg2 = (struct HashtableCpair *)(argp2);
  if (arg1) (arg1)->evals = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionMonitor_evals_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionMonitor *arg1 = (struct FunctionMonitor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct HashtableCpair *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FunctionMonitor_evals_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionMonitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionMonitor_evals_get" "', argument " "1"" of type '" "struct FunctionMonitor *""'"); 
  }
  arg1 = (struct FunctionMonitor *)(argp1);
  result = (struct HashtableCpair *) ((arg1)->evals);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HashtableCpair, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FunctionMonitor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionMonitor *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FunctionMonitor")) SWIG_fail;
  result = (struct FunctionMonitor *)calloc(1, sizeof(struct FunctionMonitor));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionMonitor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FunctionMonitor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionMonitor *arg1 = (struct FunctionMonitor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FunctionMonitor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionMonitor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FunctionMonitor" "', argument " "1"" of type '" "struct FunctionMonitor *""'"); 
  }
  arg1 = (struct FunctionMonitor *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_ff_fnd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  union ff *arg1 = (union ff *) 0 ;
  double (*arg2)(double const *,void *) = (double (*)(double const *,void *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ff_fnd_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ff_fnd_set" "', argument " "1"" of type '" "union ff *""'"); 
  }
  arg1 = (union ff *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ff_fnd_set" "', argument " "2"" of type '" "double (*)(double const *,void *)""'"); 
    }
  }
  if (arg1) (arg1)->fnd = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ff_fnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  union ff *arg1 = (union ff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double (*result)(double const *,void *) = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ff_fnd_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ff_fnd_get" "', argument " "1"" of type '" "union ff *""'"); 
  }
  arg1 = (union ff *)(argp1);
  result = (double (*)(double const *,void *)) ((arg1)->fnd);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__double_p_void__double);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ff_f1d_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  union ff *arg1 = (union ff *) 0 ;
  double (*arg2)(double,void *) = (double (*)(double,void *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ff_f1d_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ff_f1d_set" "', argument " "1"" of type '" "union ff *""'"); 
  }
  arg1 = (union ff *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ff_f1d_set" "', argument " "2"" of type '" "double (*)(double,void *)""'"); 
    }
  }
  if (arg1) (arg1)->f1d = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ff_f1d_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  union ff *arg1 = (union ff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double (*result)(double,void *) = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ff_f1d_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ff_f1d_get" "', argument " "1"" of type '" "union ff *""'"); 
  }
  arg1 = (union ff *)(argp1);
  result = (double (*)(double,void *)) ((arg1)->f1d);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_double_p_void__double);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ff_f2d_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  union ff *arg1 = (union ff *) 0 ;
  double (*arg2)(double,double,void *) = (double (*)(double,double,void *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ff_f2d_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ff_f2d_set" "', argument " "1"" of type '" "union ff *""'"); 
  }
  arg1 = (union ff *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_double_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ff_f2d_set" "', argument " "2"" of type '" "double (*)(double,double,void *)""'"); 
    }
  }
  if (arg1) (arg1)->f2d = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ff_f2d_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  union ff *arg1 = (union ff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double (*result)(double,double,void *) = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ff_f2d_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ff_f2d_get" "', argument " "1"" of type '" "union ff *""'"); 
  }
  arg1 = (union ff *)(argp1);
  result = (double (*)(double,double,void *)) ((arg1)->f2d);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_double_double_p_void__double);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  union ff *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ff")) SWIG_fail;
  result = (union ff *)calloc(1, sizeof(union ff));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ff, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  union ff *arg1 = (union ff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ff",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ff, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ff" "', argument " "1"" of type '" "union ff *""'"); 
  }
  arg1 = (union ff *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_function_monitor_initnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double (*arg1)(double const *,void *) = (double (*)(double const *,void *)) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  size_t arg4 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct FunctionMonitor *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:function_monitor_initnd",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_p_q_const__double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "function_monitor_initnd" "', argument " "1"" of type '" "double (*)(double const *,void *)""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_monitor_initnd" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "function_monitor_initnd" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "function_monitor_initnd" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  result = (struct FunctionMonitor *)function_monitor_initnd(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionMonitor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_monitor_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionMonitor *arg1 = (struct FunctionMonitor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:function_monitor_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionMonitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_monitor_free" "', argument " "1"" of type '" "struct FunctionMonitor *""'"); 
  }
  arg1 = (struct FunctionMonitor *)(argp1);
  function_monitor_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_monitor_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_monitor_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_monitor_eval" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = (double *)(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_monitor_eval" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (double)function_monitor_eval((double const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_function_monitor_print_to_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionMonitor *arg1 = (struct FunctionMonitor *) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:function_monitor_print_to_file",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionMonitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "function_monitor_print_to_file" "', argument " "1"" of type '" "struct FunctionMonitor *""'"); 
  }
  arg1 = (struct FunctionMonitor *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "function_monitor_print_to_file" "', argument " "2"" of type '" "FILE *""'"); 
  }
  arg2 = (FILE *)(argp2);
  function_monitor_print_to_file(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_storevals_main_nEvals_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals_main *arg1 = (struct storevals_main *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:storevals_main_nEvals_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_storevals_main, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "storevals_main_nEvals_set" "', argument " "1"" of type '" "struct storevals_main *""'"); 
  }
  arg1 = (struct storevals_main *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "storevals_main_nEvals_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->nEvals = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_storevals_main_nEvals_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals_main *arg1 = (struct storevals_main *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:storevals_main_nEvals_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_storevals_main, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "storevals_main_nEvals_get" "', argument " "1"" of type '" "struct storevals_main *""'"); 
  }
  arg1 = (struct storevals_main *)(argp1);
  result = (int) ((arg1)->nEvals);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_storevals_main_head_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals_main *arg1 = (struct storevals_main *) 0 ;
  struct storevals *arg2 = (struct storevals *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:storevals_main_head_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_storevals_main, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "storevals_main_head_set" "', argument " "1"" of type '" "struct storevals_main *""'"); 
  }
  arg1 = (struct storevals_main *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_storevals, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "storevals_main_head_set" "', argument " "2"" of type '" "struct storevals *""'"); 
  }
  arg2 = (struct storevals *)(argp2);
  if (arg1) (arg1)->head = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_storevals_main_head_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals_main *arg1 = (struct storevals_main *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct storevals *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:storevals_main_head_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_storevals_main, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "storevals_main_head_get" "', argument " "1"" of type '" "struct storevals_main *""'"); 
  }
  arg1 = (struct storevals_main *)(argp1);
  result = (struct storevals *) ((arg1)->head);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_storevals, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_storevals_main(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals_main *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_storevals_main")) SWIG_fail;
  result = (struct storevals_main *)calloc(1, sizeof(struct storevals_main));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_storevals_main, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_storevals_main(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals_main *arg1 = (struct storevals_main *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_storevals_main",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_storevals_main, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_storevals_main" "', argument " "1"" of type '" "struct storevals_main *""'"); 
  }
  arg1 = (struct storevals_main *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_storevals_dim_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals *arg1 = (struct storevals *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:storevals_dim_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_storevals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "storevals_dim_set" "', argument " "1"" of type '" "struct storevals *""'"); 
  }
  arg1 = (struct storevals *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "storevals_dim_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->dim = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_storevals_dim_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals *arg1 = (struct storevals *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:storevals_dim_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_storevals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "storevals_dim_get" "', argument " "1"" of type '" "struct storevals *""'"); 
  }
  arg1 = (struct storevals *)(argp1);
  result = (size_t) ((arg1)->dim);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_storevals_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals *arg1 = (struct storevals *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:storevals_x_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_storevals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "storevals_x_set" "', argument " "1"" of type '" "struct storevals *""'"); 
  }
  arg1 = (struct storevals *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "storevals_x_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_storevals_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals *arg1 = (struct storevals *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:storevals_x_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_storevals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "storevals_x_get" "', argument " "1"" of type '" "struct storevals *""'"); 
  }
  arg1 = (struct storevals *)(argp1);
  result = (double *) ((arg1)->x);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_storevals_f_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals *arg1 = (struct storevals *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:storevals_f_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_storevals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "storevals_f_set" "', argument " "1"" of type '" "struct storevals *""'"); 
  }
  arg1 = (struct storevals *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "storevals_f_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->f = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_storevals_f_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals *arg1 = (struct storevals *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:storevals_f_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_storevals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "storevals_f_get" "', argument " "1"" of type '" "struct storevals *""'"); 
  }
  arg1 = (struct storevals *)(argp1);
  result = (double) ((arg1)->f);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_storevals_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals *arg1 = (struct storevals *) 0 ;
  struct storevals *arg2 = (struct storevals *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:storevals_next_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_storevals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "storevals_next_set" "', argument " "1"" of type '" "struct storevals *""'"); 
  }
  arg1 = (struct storevals *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_storevals, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "storevals_next_set" "', argument " "2"" of type '" "struct storevals *""'"); 
  }
  arg2 = (struct storevals *)(argp2);
  if (arg1) (arg1)->next = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_storevals_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals *arg1 = (struct storevals *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct storevals *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:storevals_next_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_storevals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "storevals_next_get" "', argument " "1"" of type '" "struct storevals *""'"); 
  }
  arg1 = (struct storevals *)(argp1);
  result = (struct storevals *) ((arg1)->next);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_storevals, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_storevals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_storevals")) SWIG_fail;
  result = (struct storevals *)calloc(1, sizeof(struct storevals));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_storevals, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_storevals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals *arg1 = (struct storevals *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_storevals",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_storevals, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_storevals" "', argument " "1"" of type '" "struct storevals *""'"); 
  }
  arg1 = (struct storevals *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_PushVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals **arg1 = (struct storevals **) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PushVal",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_storevals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PushVal" "', argument " "1"" of type '" "struct storevals **""'"); 
  }
  arg1 = (struct storevals **)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PushVal" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PushVal" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PushVal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  PushVal(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PrintVals2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FILE *arg1 = (FILE *) 0 ;
  struct storevals *arg2 = (struct storevals *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PrintVals2d",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrintVals2d" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = (FILE *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_storevals, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrintVals2d" "', argument " "2"" of type '" "struct storevals *""'"); 
  }
  arg2 = (struct storevals *)(argp2);
  PrintVals2d(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeleteStoredVals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct storevals **arg1 = (struct storevals **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DeleteStoredVals",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_storevals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeleteStoredVals" "', argument " "1"" of type '" "struct storevals **""'"); 
  }
  arg1 = (struct storevals **)(argp1);
  DeleteStoredVals(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cpair_a_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Cpair *arg1 = (struct Cpair *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cpair_a_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cpair_a_set" "', argument " "1"" of type '" "struct Cpair *""'"); 
  }
  arg1 = (struct Cpair *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cpair_a_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  if (arg1->a) free((char*)arg1->a);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->a = (char *)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->a = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cpair_a_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Cpair *arg1 = (struct Cpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cpair_a_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cpair_a_get" "', argument " "1"" of type '" "struct Cpair *""'"); 
  }
  arg1 = (struct Cpair *)(argp1);
  result = (char *) ((arg1)->a);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cpair_b_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Cpair *arg1 = (struct Cpair *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cpair_b_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cpair_b_set" "', argument " "1"" of type '" "struct Cpair *""'"); 
  }
  arg1 = (struct Cpair *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cpair_b_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  if (arg1->b) free((char*)arg1->b);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->b = (char *)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->b = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cpair_b_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Cpair *arg1 = (struct Cpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cpair_b_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cpair_b_get" "', argument " "1"" of type '" "struct Cpair *""'"); 
  }
  arg1 = (struct Cpair *)(argp1);
  result = (char *) ((arg1)->b);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cpair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Cpair *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Cpair")) SWIG_fail;
  result = (struct Cpair *)calloc(1, sizeof(struct Cpair));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Cpair, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Cpair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Cpair *arg1 = (struct Cpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Cpair",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cpair, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cpair" "', argument " "1"" of type '" "struct Cpair *""'"); 
  }
  arg1 = (struct Cpair *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_cpair_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Cpair *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:cpair_create",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cpair_create" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cpair_create" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  result = (struct Cpair *)cpair_create(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Cpair, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_copy_cpair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Cpair *arg1 = (struct Cpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Cpair *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:copy_cpair",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_cpair" "', argument " "1"" of type '" "struct Cpair *""'"); 
  }
  arg1 = (struct Cpair *)(argp1);
  result = (struct Cpair *)copy_cpair(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Cpair, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_cpair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Cpair *arg1 = (struct Cpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:print_cpair",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_cpair" "', argument " "1"" of type '" "struct Cpair *""'"); 
  }
  arg1 = (struct Cpair *)(argp1);
  print_cpair(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cpair_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Cpair *arg1 = (struct Cpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:cpair_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cpair_free" "', argument " "1"" of type '" "struct Cpair *""'"); 
  }
  arg1 = (struct Cpair *)(argp1);
  cpair_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cpair_isequal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Cpair *arg1 = (struct Cpair *) 0 ;
  struct Cpair *arg2 = (struct Cpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:cpair_isequal",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cpair_isequal" "', argument " "1"" of type '" "struct Cpair *""'"); 
  }
  arg1 = (struct Cpair *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Cpair, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cpair_isequal" "', argument " "2"" of type '" "struct Cpair *""'"); 
  }
  arg2 = (struct Cpair *)(argp2);
  result = (int)cpair_isequal(arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PairList_data_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PairList *arg1 = (struct PairList *) 0 ;
  struct Cpair *arg2 = (struct Cpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PairList_data_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PairList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairList_data_set" "', argument " "1"" of type '" "struct PairList *""'"); 
  }
  arg1 = (struct PairList *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Cpair, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PairList_data_set" "', argument " "2"" of type '" "struct Cpair *""'"); 
  }
  arg2 = (struct Cpair *)(argp2);
  if (arg1) (arg1)->data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PairList_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PairList *arg1 = (struct PairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Cpair *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PairList_data_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PairList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairList_data_get" "', argument " "1"" of type '" "struct PairList *""'"); 
  }
  arg1 = (struct PairList *)(argp1);
  result = (struct Cpair *) ((arg1)->data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Cpair, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PairList_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PairList *arg1 = (struct PairList *) 0 ;
  struct PairList *arg2 = (struct PairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PairList_next_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PairList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairList_next_set" "', argument " "1"" of type '" "struct PairList *""'"); 
  }
  arg1 = (struct PairList *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PairList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PairList_next_set" "', argument " "2"" of type '" "struct PairList *""'"); 
  }
  arg2 = (struct PairList *)(argp2);
  if (arg1) (arg1)->next = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PairList_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PairList *arg1 = (struct PairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct PairList *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PairList_next_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PairList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairList_next_get" "', argument " "1"" of type '" "struct PairList *""'"); 
  }
  arg1 = (struct PairList *)(argp1);
  result = (struct PairList *) ((arg1)->next);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PairList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PairList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PairList *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PairList")) SWIG_fail;
  result = (struct PairList *)calloc(1, sizeof(struct PairList));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PairList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PairList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PairList *arg1 = (struct PairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PairList",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PairList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PairList" "', argument " "1"" of type '" "struct PairList *""'"); 
  }
  arg1 = (struct PairList *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_pair_push(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PairList **arg1 = (struct PairList **) 0 ;
  struct Cpair *arg2 = (struct Cpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:pair_push",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_PairList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pair_push" "', argument " "1"" of type '" "struct PairList **""'"); 
  }
  arg1 = (struct PairList **)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Cpair, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pair_push" "', argument " "2"" of type '" "struct Cpair *""'"); 
  }
  arg2 = (struct Cpair *)(argp2);
  pair_push(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_pair_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PairList *arg1 = (struct PairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:print_pair_list",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PairList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_pair_list" "', argument " "1"" of type '" "struct PairList *""'"); 
  }
  arg1 = (struct PairList *)(argp1);
  print_pair_list(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pair_list_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PairList **arg1 = (struct PairList **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:pair_list_delete",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_PairList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pair_list_delete" "', argument " "1"" of type '" "struct PairList **""'"); 
  }
  arg1 = (struct PairList **)(argp1);
  pair_list_delete(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pair_list_len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PairList *arg1 = (struct PairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:pair_list_len",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PairList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pair_list_len" "', argument " "1"" of type '" "struct PairList *""'"); 
  }
  arg1 = (struct PairList *)(argp1);
  result = (size_t)pair_list_len(arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pair_list_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PairList *arg1 = (struct PairList *) 0 ;
  struct Cpair *arg2 = (struct Cpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:pair_list_index",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PairList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pair_list_index" "', argument " "1"" of type '" "struct PairList *""'"); 
  }
  arg1 = (struct PairList *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Cpair, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pair_list_index" "', argument " "2"" of type '" "struct Cpair *""'"); 
  }
  arg2 = (struct Cpair *)(argp2);
  result = (size_t)pair_list_index(arg1,arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HashtableCpair_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct HashtableCpair *arg1 = (struct HashtableCpair *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HashtableCpair_size_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_HashtableCpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HashtableCpair_size_set" "', argument " "1"" of type '" "struct HashtableCpair *""'"); 
  }
  arg1 = (struct HashtableCpair *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HashtableCpair_size_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HashtableCpair_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct HashtableCpair *arg1 = (struct HashtableCpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HashtableCpair_size_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_HashtableCpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HashtableCpair_size_get" "', argument " "1"" of type '" "struct HashtableCpair *""'"); 
  }
  arg1 = (struct HashtableCpair *)(argp1);
  result = (size_t) ((arg1)->size);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HashtableCpair_table_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct HashtableCpair *arg1 = (struct HashtableCpair *) 0 ;
  struct PairList **arg2 = (struct PairList **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HashtableCpair_table_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_HashtableCpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HashtableCpair_table_set" "', argument " "1"" of type '" "struct HashtableCpair *""'"); 
  }
  arg1 = (struct HashtableCpair *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_PairList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HashtableCpair_table_set" "', argument " "2"" of type '" "struct PairList **""'"); 
  }
  arg2 = (struct PairList **)(argp2);
  if (arg1) (arg1)->table = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HashtableCpair_table_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct HashtableCpair *arg1 = (struct HashtableCpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct PairList **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HashtableCpair_table_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_HashtableCpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HashtableCpair_table_get" "', argument " "1"" of type '" "struct HashtableCpair *""'"); 
  }
  arg1 = (struct HashtableCpair *)(argp1);
  result = (struct PairList **) ((arg1)->table);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_PairList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HashtableCpair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct HashtableCpair *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HashtableCpair")) SWIG_fail;
  result = (struct HashtableCpair *)calloc(1, sizeof(struct HashtableCpair));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HashtableCpair, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HashtableCpair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct HashtableCpair *arg1 = (struct HashtableCpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HashtableCpair",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_HashtableCpair, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HashtableCpair" "', argument " "1"" of type '" "struct HashtableCpair *""'"); 
  }
  arg1 = (struct HashtableCpair *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_create_hashtable_cp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct HashtableCpair *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:create_hashtable_cp",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "create_hashtable_cp" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct HashtableCpair *)create_hashtable_cp(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HashtableCpair, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lookup_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct HashtableCpair *arg1 = (struct HashtableCpair *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:lookup_key",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_HashtableCpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lookup_key" "', argument " "1"" of type '" "struct HashtableCpair *""'"); 
  }
  arg1 = (struct HashtableCpair *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lookup_key" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  result = (char *)lookup_key(arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_add_cpair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct HashtableCpair *arg1 = (struct HashtableCpair *) 0 ;
  struct Cpair *arg2 = (struct Cpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:add_cpair",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_HashtableCpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "add_cpair" "', argument " "1"" of type '" "struct HashtableCpair *""'"); 
  }
  arg1 = (struct HashtableCpair *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Cpair, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "add_cpair" "', argument " "2"" of type '" "struct Cpair *""'"); 
  }
  arg2 = (struct Cpair *)(argp2);
  result = (int)add_cpair(arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_free_hashtable_cp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct HashtableCpair *arg1 = (struct HashtableCpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:free_hashtable_cp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_HashtableCpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "free_hashtable_cp" "', argument " "1"" of type '" "struct HashtableCpair *""'"); 
  }
  arg1 = (struct HashtableCpair *)(argp1);
  free_hashtable_cp(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nstored_hashtable_cp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct HashtableCpair *arg1 = (struct HashtableCpair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:nstored_hashtable_cp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_HashtableCpair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nstored_hashtable_cp" "', argument " "1"" of type '" "struct HashtableCpair *""'"); 
  }
  arg1 = (struct HashtableCpair *)(argp1);
  result = (size_t)nstored_hashtable_cp(arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hashsimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  char *arg2 = (char *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:hashsimple",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "hashsimple" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hashsimple" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  result = (size_t)hashsimple(arg1,arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum poly_type arg1 ;
  double arg2 ;
  double arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct PwPolyOpts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:pw_poly_opts_alloc",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pw_poly_opts_alloc" "', argument " "1"" of type '" "enum poly_type""'");
  } 
  arg1 = (enum poly_type)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pw_poly_opts_alloc" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pw_poly_opts_alloc" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  result = (struct PwPolyOpts *)pw_poly_opts_alloc(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:pw_poly_opts_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_free" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  pw_poly_opts_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_free_deep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts **arg1 = (struct PwPolyOpts **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:pw_poly_opts_free_deep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_free_deep" "', argument " "1"" of type '" "struct PwPolyOpts **""'"); 
  }
  arg1 = (struct PwPolyOpts **)(argp1);
  pw_poly_opts_free_deep(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_set_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:pw_poly_opts_set_lb",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_set_lb" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pw_poly_opts_set_lb" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  pw_poly_opts_set_lb(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_get_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:pw_poly_opts_get_lb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_get_lb" "', argument " "1"" of type '" "struct PwPolyOpts const *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  result = (double)pw_poly_opts_get_lb((struct PwPolyOpts const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_set_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:pw_poly_opts_set_ub",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_set_ub" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pw_poly_opts_set_ub" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  pw_poly_opts_set_ub(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_get_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:pw_poly_opts_get_ub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_get_ub" "', argument " "1"" of type '" "struct PwPolyOpts const *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  result = (double)pw_poly_opts_get_ub((struct PwPolyOpts const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_set_ptype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  enum poly_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:pw_poly_opts_set_ptype",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_set_ptype" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pw_poly_opts_set_ptype" "', argument " "2"" of type '" "enum poly_type""'");
  } 
  arg2 = (enum poly_type)(val2);
  pw_poly_opts_set_ptype(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_get_ptype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum poly_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:pw_poly_opts_get_ptype",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_get_ptype" "', argument " "1"" of type '" "struct PwPolyOpts const *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  result = (enum poly_type)pw_poly_opts_get_ptype((struct PwPolyOpts const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_set_minsize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:pw_poly_opts_set_minsize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_set_minsize" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pw_poly_opts_set_minsize" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  pw_poly_opts_set_minsize(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_set_maxorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:pw_poly_opts_set_maxorder",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_set_maxorder" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pw_poly_opts_set_maxorder" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  pw_poly_opts_set_maxorder(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_set_nregions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:pw_poly_opts_set_nregions",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_set_nregions" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pw_poly_opts_set_nregions" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  pw_poly_opts_set_nregions(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_set_pts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:pw_poly_opts_set_pts",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_set_pts" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pw_poly_opts_set_pts" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pw_poly_opts_set_pts" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  pw_poly_opts_set_pts(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_set_tol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:pw_poly_opts_set_tol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_set_tol" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pw_poly_opts_set_tol" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  pw_poly_opts_set_tol(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_set_coeffs_check(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:pw_poly_opts_set_coeffs_check",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_set_coeffs_check" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pw_poly_opts_set_coeffs_check" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  pw_poly_opts_set_coeffs_check(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_get_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:pw_poly_opts_get_nparams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_get_nparams" "', argument " "1"" of type '" "struct PwPolyOpts const *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  result = (size_t)pw_poly_opts_get_nparams((struct PwPolyOpts const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_poly_opts_set_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:pw_poly_opts_set_nparams",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pw_poly_opts_set_nparams" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pw_poly_opts_set_nparams" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  pw_poly_opts_set_nparams(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewisePoly_leaf_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PiecewisePoly_leaf_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewisePoly_leaf_set" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PiecewisePoly_leaf_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->leaf = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewisePoly_leaf_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PiecewisePoly_leaf_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewisePoly_leaf_get" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (int) ((arg1)->leaf);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewisePoly_nbranches_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PiecewisePoly_nbranches_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewisePoly_nbranches_set" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PiecewisePoly_nbranches_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->nbranches = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewisePoly_nbranches_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PiecewisePoly_nbranches_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewisePoly_nbranches_get" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (size_t) ((arg1)->nbranches);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewisePoly_branches_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  struct PiecewisePoly **arg2 = (struct PiecewisePoly **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PiecewisePoly_branches_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewisePoly_branches_set" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PiecewisePoly_branches_set" "', argument " "2"" of type '" "struct PiecewisePoly **""'"); 
  }
  arg2 = (struct PiecewisePoly **)(argp2);
  if (arg1) (arg1)->branches = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewisePoly_branches_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct PiecewisePoly **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PiecewisePoly_branches_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewisePoly_branches_get" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (struct PiecewisePoly **) ((arg1)->branches);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewisePoly_ope_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  struct OrthPolyExpansion *arg2 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PiecewisePoly_ope_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewisePoly_ope_set" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OrthPolyExpansion, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PiecewisePoly_ope_set" "', argument " "2"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg2 = (struct OrthPolyExpansion *)(argp2);
  if (arg1) (arg1)->ope = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewisePoly_ope_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PiecewisePoly_ope_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewisePoly_ope_get" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (struct OrthPolyExpansion *) ((arg1)->ope);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewisePoly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PiecewisePoly")) SWIG_fail;
  result = (struct PiecewisePoly *)calloc(1, sizeof(struct PiecewisePoly));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewisePoly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PiecewisePoly",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewisePoly" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_piecewise_poly_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":piecewise_poly_alloc")) SWIG_fail;
  result = (struct PiecewisePoly *)piecewise_poly_alloc();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_array_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct PiecewisePoly **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_array_alloc",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "piecewise_poly_array_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct PiecewisePoly **)piecewise_poly_array_alloc(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_copy" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (struct PiecewisePoly *)piecewise_poly_copy((struct PiecewisePoly const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_free" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  piecewise_poly_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_array_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly **arg1 = (struct PiecewisePoly **) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_array_free",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_array_free" "', argument " "1"" of type '" "struct PiecewisePoly **""'"); 
  }
  arg1 = (struct PiecewisePoly **)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_array_free" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  piecewise_poly_array_free(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_get_ptype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum poly_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_get_ptype",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_get_ptype" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (enum poly_type)piecewise_poly_get_ptype((struct PiecewisePoly const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_genorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct PwPolyOpts *arg2 = (struct PwPolyOpts *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_genorder",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "piecewise_poly_genorder" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_genorder" "', argument " "2"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg2 = (struct PwPolyOpts *)(argp2);
  result = (struct PiecewisePoly *)piecewise_poly_genorder(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_constant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct PwPolyOpts *arg2 = (struct PwPolyOpts *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_constant",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "piecewise_poly_constant" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_constant" "', argument " "2"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg2 = (struct PwPolyOpts *)(argp2);
  result = (struct PiecewisePoly *)piecewise_poly_constant(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_zero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_zero",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_zero" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_zero" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  result = (struct PiecewisePoly *)piecewise_poly_zero(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_linear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  struct PwPolyOpts *arg3 = (struct PwPolyOpts *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:piecewise_poly_linear",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "piecewise_poly_linear" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_linear" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_linear" "', argument " "3"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg3 = (struct PwPolyOpts *)(argp3);
  result = (struct PiecewisePoly *)piecewise_poly_linear(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_linear_update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:piecewise_poly_linear_update",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_linear_update" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_linear_update" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "piecewise_poly_linear_update" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  result = (int)piecewise_poly_linear_update(arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_quadratic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  struct PwPolyOpts *arg3 = (struct PwPolyOpts *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:piecewise_poly_quadratic",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "piecewise_poly_quadratic" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_quadratic" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_quadratic" "', argument " "3"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg3 = (struct PwPolyOpts *)(argp3);
  result = (struct PiecewisePoly *)piecewise_poly_quadratic(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_splitn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:piecewise_poly_splitn",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_splitn" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_splitn" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_splitn" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  piecewise_poly_splitn(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_isflat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_isflat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_isflat" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (int)piecewise_poly_isflat((struct PiecewisePoly const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_get_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_get_lb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_get_lb" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (double)piecewise_poly_get_lb((struct PiecewisePoly const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_get_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_get_ub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_get_ub" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (double)piecewise_poly_get_ub((struct PiecewisePoly const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_nregions_base(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t *arg1 = (size_t *) 0 ;
  struct PiecewisePoly *arg2 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_nregions_base",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_nregions_base" "', argument " "1"" of type '" "size_t *""'"); 
  }
  arg1 = (size_t *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_nregions_base" "', argument " "2"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg2 = (struct PiecewisePoly *)(argp2);
  piecewise_poly_nregions_base(arg1,(struct PiecewisePoly const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_nregions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_nregions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_nregions" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (size_t)piecewise_poly_nregions((struct PiecewisePoly const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_boundaries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  double **arg3 = (double **) 0 ;
  size_t *arg4 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:piecewise_poly_boundaries",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_boundaries" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_boundaries" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_boundaries" "', argument " "3"" of type '" "double **""'"); 
  }
  arg3 = (double **)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "piecewise_poly_boundaries" "', argument " "4"" of type '" "size_t *""'"); 
  }
  arg4 = (size_t *)(argp4);
  piecewise_poly_boundaries((struct PiecewisePoly const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_eval" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_eval" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)piecewise_poly_eval((struct PiecewisePoly const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_deriv_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_deriv_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_deriv_eval" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_deriv_eval" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)piecewise_poly_deriv_eval((struct PiecewisePoly const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_evalN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:piecewise_poly_evalN",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_evalN" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_evalN" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_evalN" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "piecewise_poly_evalN" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "piecewise_poly_evalN" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "piecewise_poly_evalN" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  piecewise_poly_evalN((struct PiecewisePoly const *)arg1,arg2,(double const *)arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct PiecewisePoly *arg2 = (struct PiecewisePoly *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_scale",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "piecewise_poly_scale" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_scale" "', argument " "2"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg2 = (struct PiecewisePoly *)(argp2);
  piecewise_poly_scale(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_deriv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_deriv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_deriv" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (struct PiecewisePoly *)piecewise_poly_deriv((struct PiecewisePoly const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_dderiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_dderiv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_dderiv" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (struct PiecewisePoly *)piecewise_poly_dderiv((struct PiecewisePoly const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_dderiv_periodic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_dderiv_periodic",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_dderiv_periodic" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (struct PiecewisePoly *)piecewise_poly_dderiv_periodic((struct PiecewisePoly const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_integrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_integrate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_integrate" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (double)piecewise_poly_integrate((struct PiecewisePoly const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_integrate_weighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_integrate_weighted",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_integrate_weighted" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (double)piecewise_poly_integrate_weighted((struct PiecewisePoly const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_real_roots(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_real_roots",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_real_roots" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_real_roots" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (double *)piecewise_poly_real_roots((struct PiecewisePoly const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_max",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_max" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_max" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (double)piecewise_poly_max((struct PiecewisePoly const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_min",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_min" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_min" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (double)piecewise_poly_min((struct PiecewisePoly const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_absmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  double *arg2 = (double *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:piecewise_poly_absmax",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_absmax" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_absmax" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_absmax" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (double)piecewise_poly_absmax((struct PiecewisePoly const *)arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_norm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_norm" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (double)piecewise_poly_norm((struct PiecewisePoly const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_flip_sign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_flip_sign",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_flip_sign" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  piecewise_poly_flip_sign(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_copy_leaves(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  struct PiecewisePoly **arg2 = (struct PiecewisePoly **) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:piecewise_poly_copy_leaves",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_copy_leaves" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_copy_leaves" "', argument " "2"" of type '" "struct PiecewisePoly **""'"); 
  }
  arg2 = (struct PiecewisePoly **)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_copy_leaves" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  piecewise_poly_copy_leaves((struct PiecewisePoly const *)arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_ref_leaves(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  struct PiecewisePoly **arg2 = (struct PiecewisePoly **) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:piecewise_poly_ref_leaves",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_ref_leaves" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_ref_leaves" "', argument " "2"" of type '" "struct PiecewisePoly **""'"); 
  }
  arg2 = (struct PiecewisePoly **)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_ref_leaves" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  piecewise_poly_ref_leaves(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_flatten(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_flatten",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_flatten" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  piecewise_poly_flatten(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_finer_grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:piecewise_poly_finer_grid",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_finer_grid" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_finer_grid" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_finer_grid" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (struct PiecewisePoly *)piecewise_poly_finer_grid((struct PiecewisePoly const *)arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_match(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  struct PiecewisePoly **arg2 = (struct PiecewisePoly **) 0 ;
  struct PiecewisePoly *arg3 = (struct PiecewisePoly *) 0 ;
  struct PiecewisePoly **arg4 = (struct PiecewisePoly **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:piecewise_poly_match",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_match" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_match" "', argument " "2"" of type '" "struct PiecewisePoly **""'"); 
  }
  arg2 = (struct PiecewisePoly **)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_match" "', argument " "3"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg3 = (struct PiecewisePoly *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "piecewise_poly_match" "', argument " "4"" of type '" "struct PiecewisePoly **""'"); 
  }
  arg4 = (struct PiecewisePoly **)(argp4);
  piecewise_poly_match((struct PiecewisePoly const *)arg1,arg2,(struct PiecewisePoly const *)arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_prod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  struct PiecewisePoly *arg2 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_prod",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_prod" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_prod" "', argument " "2"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg2 = (struct PiecewisePoly *)(argp2);
  result = (struct PiecewisePoly *)piecewise_poly_prod((struct PiecewisePoly const *)arg1,(struct PiecewisePoly const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_inner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  struct PiecewisePoly *arg2 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_inner",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_inner" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_inner" "', argument " "2"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg2 = (struct PiecewisePoly *)(argp2);
  result = (double)piecewise_poly_inner((struct PiecewisePoly const *)arg1,(struct PiecewisePoly const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_axpy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct PiecewisePoly *arg2 = (struct PiecewisePoly *) 0 ;
  struct PiecewisePoly *arg3 = (struct PiecewisePoly *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:piecewise_poly_axpy",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "piecewise_poly_axpy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_axpy" "', argument " "2"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg2 = (struct PiecewisePoly *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_axpy" "', argument " "3"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg3 = (struct PiecewisePoly *)(argp3);
  result = (int)piecewise_poly_axpy(arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_daxpby(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct PiecewisePoly *arg2 = (struct PiecewisePoly *) 0 ;
  double arg3 ;
  struct PiecewisePoly *arg4 = (struct PiecewisePoly *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:piecewise_poly_daxpby",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "piecewise_poly_daxpby" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_daxpby" "', argument " "2"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg2 = (struct PiecewisePoly *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "piecewise_poly_daxpby" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "piecewise_poly_daxpby" "', argument " "4"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg4 = (struct PiecewisePoly *)(argp4);
  result = (struct PiecewisePoly *)piecewise_poly_daxpby(arg1,(struct PiecewisePoly const *)arg2,arg3,(struct PiecewisePoly const *)arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_matched_daxpby(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct PiecewisePoly *arg2 = (struct PiecewisePoly *) 0 ;
  double arg3 ;
  struct PiecewisePoly *arg4 = (struct PiecewisePoly *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:piecewise_poly_matched_daxpby",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "piecewise_poly_matched_daxpby" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_matched_daxpby" "', argument " "2"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg2 = (struct PiecewisePoly *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "piecewise_poly_matched_daxpby" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "piecewise_poly_matched_daxpby" "', argument " "4"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg4 = (struct PiecewisePoly *)(argp4);
  result = (struct PiecewisePoly *)piecewise_poly_matched_daxpby(arg1,(struct PiecewisePoly const *)arg2,arg3,(struct PiecewisePoly const *)arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_matched_prod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  struct PiecewisePoly *arg2 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_matched_prod",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_matched_prod" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_matched_prod" "', argument " "2"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg2 = (struct PiecewisePoly *)(argp2);
  result = (struct PiecewisePoly *)piecewise_poly_matched_prod((struct PiecewisePoly const *)arg1,(struct PiecewisePoly const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_approx1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  struct Fwrap *arg2 = (struct Fwrap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_approx1",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_approx1" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_approx1" "', argument " "2"" of type '" "struct Fwrap *""'"); 
  }
  arg2 = (struct Fwrap *)(argp2);
  result = (struct PiecewisePoly *)piecewise_poly_approx1(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_approx1_adapt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  struct Fwrap *arg2 = (struct Fwrap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_approx1_adapt",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_approx1_adapt" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_approx1_adapt" "', argument " "2"" of type '" "struct Fwrap *""'"); 
  }
  arg2 = (struct Fwrap *)(argp2);
  result = (struct PiecewisePoly *)piecewise_poly_approx1_adapt(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_check_discontinuity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  struct PiecewisePoly *arg2 = (struct PiecewisePoly *) 0 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:piecewise_poly_check_discontinuity",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_check_discontinuity" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_check_discontinuity" "', argument " "2"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg2 = (struct PiecewisePoly *)(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "piecewise_poly_check_discontinuity" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "piecewise_poly_check_discontinuity" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  result = (int)piecewise_poly_check_discontinuity(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minmod_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:minmod_eval",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "minmod_eval" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "minmod_eval" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "minmod_eval" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "minmod_eval" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "minmod_eval" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "minmod_eval" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  result = (double)minmod_eval(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minmod_disc_exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:minmod_disc_exists",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "minmod_disc_exists" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "minmod_disc_exists" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "minmod_disc_exists" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "minmod_disc_exists" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "minmod_disc_exists" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "minmod_disc_exists" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  result = (int)minmod_disc_exists(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_locate_jumps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Fwrap *arg1 = (struct Fwrap *) 0 ;
  double arg2 ;
  double arg3 ;
  size_t arg4 ;
  double arg5 ;
  double **arg6 = (double **) 0 ;
  size_t *arg7 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:locate_jumps",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "locate_jumps" "', argument " "1"" of type '" "struct Fwrap *""'"); 
  }
  arg1 = (struct Fwrap *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "locate_jumps" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "locate_jumps" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "locate_jumps" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "locate_jumps" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "locate_jumps" "', argument " "6"" of type '" "double **""'"); 
  }
  arg6 = (double **)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "locate_jumps" "', argument " "7"" of type '" "size_t *""'"); 
  }
  arg7 = (size_t *)(argp7);
  locate_jumps(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_serialize_piecewise_poly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct PiecewisePoly *arg2 = (struct PiecewisePoly *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:serialize_piecewise_poly",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "serialize_piecewise_poly" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "serialize_piecewise_poly" "', argument " "2"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg2 = (struct PiecewisePoly *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "serialize_piecewise_poly" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (unsigned char *)serialize_piecewise_poly(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_deserialize_piecewise_poly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct PiecewisePoly **arg2 = (struct PiecewisePoly **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:deserialize_piecewise_poly",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deserialize_piecewise_poly" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "deserialize_piecewise_poly" "', argument " "2"" of type '" "struct PiecewisePoly **""'"); 
  }
  arg2 = (struct PiecewisePoly **)(argp2);
  result = (unsigned char *)deserialize_piecewise_poly(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_piecewise_poly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  size_t arg2 ;
  void *arg3 = (void *) 0 ;
  FILE *arg4 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:print_piecewise_poly",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_piecewise_poly" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "print_piecewise_poly" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "print_piecewise_poly" "', argument " "3"" of type '" "void *""'"); 
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "print_piecewise_poly" "', argument " "4"" of type '" "FILE *""'"); 
  }
  arg4 = (FILE *)(argp4);
  print_piecewise_poly(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_savetxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:piecewise_poly_savetxt",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_savetxt" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_savetxt" "', argument " "2"" of type '" "FILE *""'"); 
  }
  arg2 = (FILE *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "piecewise_poly_savetxt" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  piecewise_poly_savetxt((struct PiecewisePoly const *)arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_loadtxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FILE *arg1 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_loadtxt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_loadtxt" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = (FILE *)(argp1);
  result = (struct PiecewisePoly *)piecewise_poly_loadtxt(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_get_num_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:piecewise_poly_get_num_params",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_get_num_params" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  result = (size_t)piecewise_poly_get_num_params((struct PiecewisePoly const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_update_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:piecewise_poly_update_params",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_update_params" "', argument " "1"" of type '" "struct PiecewisePoly *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_update_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_update_params" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (int)piecewise_poly_update_params(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_param_grad_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:piecewise_poly_param_grad_eval",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_param_grad_eval" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_param_grad_eval" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_param_grad_eval" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "piecewise_poly_param_grad_eval" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (int)piecewise_poly_param_grad_eval((struct PiecewisePoly const *)arg1,arg2,(double const *)arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_param_grad_eval2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  double arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:piecewise_poly_param_grad_eval2",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_param_grad_eval2" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_param_grad_eval2" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_param_grad_eval2" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (double)piecewise_poly_param_grad_eval2((struct PiecewisePoly const *)arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_squared_norm_param_grad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  double arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:piecewise_poly_squared_norm_param_grad",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_squared_norm_param_grad" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_squared_norm_param_grad" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_squared_norm_param_grad" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (int)piecewise_poly_squared_norm_param_grad((struct PiecewisePoly const *)arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_get_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_get_params",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_get_params" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_get_params" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (size_t)piecewise_poly_get_params((struct PiecewisePoly const *)arg1,arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_get_params_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PiecewisePoly *arg1 = (struct PiecewisePoly *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:piecewise_poly_get_params_ref",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_get_params_ref" "', argument " "1"" of type '" "struct PiecewisePoly const *""'"); 
  }
  arg1 = (struct PiecewisePoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "piecewise_poly_get_params_ref" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (double *)piecewise_poly_get_params_ref((struct PiecewisePoly const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_piecewise_poly_create_with_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PwPolyOpts *arg1 = (struct PwPolyOpts *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct PiecewisePoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:piecewise_poly_create_with_params",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PwPolyOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "piecewise_poly_create_with_params" "', argument " "1"" of type '" "struct PwPolyOpts *""'"); 
  }
  arg1 = (struct PwPolyOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "piecewise_poly_create_with_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "piecewise_poly_create_with_params" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (struct PiecewisePoly *)piecewise_poly_create_with_params(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewisePoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pivot_get_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Pivot *arg1 = (struct Pivot *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:pivot_get_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pivot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pivot_get_size" "', argument " "1"" of type '" "struct Pivot const *""'"); 
  }
  arg1 = (struct Pivot *)(argp1);
  result = (size_t)pivot_get_size((struct Pivot const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pivot_get_ind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Pivot *arg1 = (struct Pivot *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:pivot_get_ind",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pivot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pivot_get_ind" "', argument " "1"" of type '" "struct Pivot const *""'"); 
  }
  arg1 = (struct Pivot *)(argp1);
  result = (size_t)pivot_get_ind((struct Pivot const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pivot_get_loc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Pivot *arg1 = (struct Pivot *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:pivot_get_loc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pivot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pivot_get_loc" "', argument " "1"" of type '" "struct Pivot const *""'"); 
  }
  arg1 = (struct Pivot *)(argp1);
  result = (void *)pivot_get_loc((struct Pivot const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pivot_set_ind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Pivot *arg1 = (struct Pivot *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:pivot_set_ind",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pivot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pivot_set_ind" "', argument " "1"" of type '" "struct Pivot *""'"); 
  }
  arg1 = (struct Pivot *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pivot_set_ind" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  pivot_set_ind(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pivot_set_get_pivot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct PivotSet *arg1 = (struct PivotSet *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct Pivot *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:pivot_set_get_pivot",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PivotSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pivot_set_get_pivot" "', argument " "1"" of type '" "struct PivotSet *""'"); 
  }
  arg1 = (struct PivotSet *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pivot_set_get_pivot" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (struct Pivot *)pivot_set_get_pivot(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pivot, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_space_mapping_map(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SpaceMapping *arg1 = (struct SpaceMapping *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:space_mapping_map",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SpaceMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "space_mapping_map" "', argument " "1"" of type '" "struct SpaceMapping *""'"); 
  }
  arg1 = (struct SpaceMapping *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "space_mapping_map" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)space_mapping_map(arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_space_mapping_map_inverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SpaceMapping *arg1 = (struct SpaceMapping *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:space_mapping_map_inverse",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SpaceMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "space_mapping_map_inverse" "', argument " "1"" of type '" "struct SpaceMapping *""'"); 
  }
  arg1 = (struct SpaceMapping *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "space_mapping_map_inverse" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)space_mapping_map_inverse(arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_space_mapping_map_deriv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SpaceMapping *arg1 = (struct SpaceMapping *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:space_mapping_map_deriv",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SpaceMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "space_mapping_map_deriv" "', argument " "1"" of type '" "struct SpaceMapping *""'"); 
  }
  arg1 = (struct SpaceMapping *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "space_mapping_map_deriv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)space_mapping_map_deriv(arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_space_mapping_map_inverse_deriv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct SpaceMapping *arg1 = (struct SpaceMapping *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:space_mapping_map_inverse_deriv",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SpaceMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "space_mapping_map_inverse_deriv" "', argument " "1"" of type '" "struct SpaceMapping *""'"); 
  }
  arg1 = (struct SpaceMapping *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "space_mapping_map_inverse_deriv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)space_mapping_map_inverse_deriv(arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum poly_type arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct OpeOpts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ope_opts_alloc",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ope_opts_alloc" "', argument " "1"" of type '" "enum poly_type""'");
  } 
  arg1 = (enum poly_type)(val1);
  result = (struct OpeOpts *)ope_opts_alloc(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpeOpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ope_opts_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_free" "', argument " "1"" of type '" "struct OpeOpts *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ope_opts_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_free_deep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts **arg1 = (struct OpeOpts **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ope_opts_free_deep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_free_deep" "', argument " "1"" of type '" "struct OpeOpts **""'"); 
  }
  arg1 = (struct OpeOpts **)(argp1);
  ope_opts_free_deep(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_set_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ope_opts_set_start",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_set_start" "', argument " "1"" of type '" "struct OpeOpts *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ope_opts_set_start" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ope_opts_set_start(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_get_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ope_opts_get_start",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_get_start" "', argument " "1"" of type '" "struct OpeOpts const *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  result = (size_t)ope_opts_get_start((struct OpeOpts const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_set_maxnum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ope_opts_set_maxnum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_set_maxnum" "', argument " "1"" of type '" "struct OpeOpts *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ope_opts_set_maxnum" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ope_opts_set_maxnum(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_get_maxnum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ope_opts_get_maxnum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_get_maxnum" "', argument " "1"" of type '" "struct OpeOpts const *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  result = (size_t)ope_opts_get_maxnum((struct OpeOpts const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_set_coeffs_check(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ope_opts_set_coeffs_check",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_set_coeffs_check" "', argument " "1"" of type '" "struct OpeOpts *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ope_opts_set_coeffs_check" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ope_opts_set_coeffs_check(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_set_tol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ope_opts_set_tol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_set_tol" "', argument " "1"" of type '" "struct OpeOpts *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ope_opts_set_tol" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ope_opts_set_tol(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_set_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ope_opts_set_lb",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_set_lb" "', argument " "1"" of type '" "struct OpeOpts *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ope_opts_set_lb" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ope_opts_set_lb(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_get_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ope_opts_get_lb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_get_lb" "', argument " "1"" of type '" "struct OpeOpts const *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  result = (double)ope_opts_get_lb((struct OpeOpts const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_set_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ope_opts_set_ub",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_set_ub" "', argument " "1"" of type '" "struct OpeOpts *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ope_opts_set_ub" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ope_opts_set_ub(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_get_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ope_opts_get_ub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_get_ub" "', argument " "1"" of type '" "struct OpeOpts const *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  result = (double)ope_opts_get_ub((struct OpeOpts const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_set_mean_and_std(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ope_opts_set_mean_and_std",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_set_mean_and_std" "', argument " "1"" of type '" "struct OpeOpts *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ope_opts_set_mean_and_std" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ope_opts_set_mean_and_std" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ope_opts_set_mean_and_std(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_set_ptype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  enum poly_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ope_opts_set_ptype",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_set_ptype" "', argument " "1"" of type '" "struct OpeOpts *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ope_opts_set_ptype" "', argument " "2"" of type '" "enum poly_type""'");
  } 
  arg2 = (enum poly_type)(val2);
  ope_opts_set_ptype(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_get_ptype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum poly_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ope_opts_get_ptype",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_get_ptype" "', argument " "1"" of type '" "struct OpeOpts const *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  result = (enum poly_type)ope_opts_get_ptype((struct OpeOpts const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_set_qrule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  enum quad_rule arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ope_opts_set_qrule",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_set_qrule" "', argument " "1"" of type '" "struct OpeOpts *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ope_opts_set_qrule" "', argument " "2"" of type '" "enum quad_rule""'");
  } 
  arg2 = (enum quad_rule)(val2);
  ope_opts_set_qrule(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_get_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ope_opts_get_nparams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_get_nparams" "', argument " "1"" of type '" "struct OpeOpts const *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  result = (size_t)ope_opts_get_nparams((struct OpeOpts const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_set_nparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ope_opts_set_nparams",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_set_nparams" "', argument " "1"" of type '" "struct OpeOpts *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ope_opts_set_nparams" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ope_opts_set_nparams(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ope_opts_set_kristoffel_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ope_opts_set_kristoffel_weight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ope_opts_set_kristoffel_weight" "', argument " "1"" of type '" "struct OpeOpts *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ope_opts_set_kristoffel_weight" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ope_opts_set_kristoffel_weight(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StandardPoly_ptype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *arg1 = (struct StandardPoly *) 0 ;
  enum poly_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StandardPoly_ptype_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StandardPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPoly_ptype_set" "', argument " "1"" of type '" "struct StandardPoly *""'"); 
  }
  arg1 = (struct StandardPoly *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StandardPoly_ptype_set" "', argument " "2"" of type '" "enum poly_type""'");
  } 
  arg2 = (enum poly_type)(val2);
  if (arg1) (arg1)->ptype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StandardPoly_ptype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *arg1 = (struct StandardPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum poly_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StandardPoly_ptype_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StandardPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPoly_ptype_get" "', argument " "1"" of type '" "struct StandardPoly *""'"); 
  }
  arg1 = (struct StandardPoly *)(argp1);
  result = (enum poly_type) ((arg1)->ptype);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StandardPoly_num_poly_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *arg1 = (struct StandardPoly *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StandardPoly_num_poly_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StandardPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPoly_num_poly_set" "', argument " "1"" of type '" "struct StandardPoly *""'"); 
  }
  arg1 = (struct StandardPoly *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StandardPoly_num_poly_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->num_poly = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StandardPoly_num_poly_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *arg1 = (struct StandardPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StandardPoly_num_poly_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StandardPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPoly_num_poly_get" "', argument " "1"" of type '" "struct StandardPoly *""'"); 
  }
  arg1 = (struct StandardPoly *)(argp1);
  result = (size_t) ((arg1)->num_poly);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StandardPoly_lower_bound_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *arg1 = (struct StandardPoly *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StandardPoly_lower_bound_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StandardPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPoly_lower_bound_set" "', argument " "1"" of type '" "struct StandardPoly *""'"); 
  }
  arg1 = (struct StandardPoly *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StandardPoly_lower_bound_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->lower_bound = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StandardPoly_lower_bound_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *arg1 = (struct StandardPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StandardPoly_lower_bound_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StandardPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPoly_lower_bound_get" "', argument " "1"" of type '" "struct StandardPoly *""'"); 
  }
  arg1 = (struct StandardPoly *)(argp1);
  result = (double) ((arg1)->lower_bound);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StandardPoly_upper_bound_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *arg1 = (struct StandardPoly *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StandardPoly_upper_bound_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StandardPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPoly_upper_bound_set" "', argument " "1"" of type '" "struct StandardPoly *""'"); 
  }
  arg1 = (struct StandardPoly *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StandardPoly_upper_bound_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->upper_bound = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StandardPoly_upper_bound_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *arg1 = (struct StandardPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StandardPoly_upper_bound_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StandardPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPoly_upper_bound_get" "', argument " "1"" of type '" "struct StandardPoly *""'"); 
  }
  arg1 = (struct StandardPoly *)(argp1);
  result = (double) ((arg1)->upper_bound);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StandardPoly_coeff_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *arg1 = (struct StandardPoly *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StandardPoly_coeff_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StandardPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPoly_coeff_set" "', argument " "1"" of type '" "struct StandardPoly *""'"); 
  }
  arg1 = (struct StandardPoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StandardPoly_coeff_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->coeff = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StandardPoly_coeff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *arg1 = (struct StandardPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StandardPoly_coeff_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StandardPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPoly_coeff_get" "', argument " "1"" of type '" "struct StandardPoly *""'"); 
  }
  arg1 = (struct StandardPoly *)(argp1);
  result = (double *) ((arg1)->coeff);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StandardPoly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StandardPoly")) SWIG_fail;
  result = (struct StandardPoly *)calloc(1, sizeof(struct StandardPoly));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StandardPoly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StandardPoly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *arg1 = (struct StandardPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StandardPoly",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StandardPoly, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StandardPoly" "', argument " "1"" of type '" "struct StandardPoly *""'"); 
  }
  arg1 = (struct StandardPoly *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_standard_poly_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double arg2 ;
  double arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct StandardPoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:standard_poly_init",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "standard_poly_init" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "standard_poly_init" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "standard_poly_init" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  result = (struct StandardPoly *)standard_poly_init(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StandardPoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_standard_poly_deriv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *arg1 = (struct StandardPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct StandardPoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:standard_poly_deriv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StandardPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "standard_poly_deriv" "', argument " "1"" of type '" "struct StandardPoly *""'"); 
  }
  arg1 = (struct StandardPoly *)(argp1);
  result = (struct StandardPoly *)standard_poly_deriv(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StandardPoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_standard_poly_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *arg1 = (struct StandardPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:standard_poly_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StandardPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "standard_poly_free" "', argument " "1"" of type '" "struct StandardPoly *""'"); 
  }
  arg1 = (struct StandardPoly *)(argp1);
  standard_poly_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_ptype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  enum poly_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPoly_ptype_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_ptype_set" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthPoly_ptype_set" "', argument " "2"" of type '" "enum poly_type""'");
  } 
  arg2 = (enum poly_type)(val2);
  if (arg1) (arg1)->ptype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_ptype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum poly_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPoly_ptype_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_ptype_get" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  result = (enum poly_type) ((arg1)->ptype);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_an_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  double (*arg2)(size_t) = (double (*)(size_t)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPoly_an_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_an_set" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_unsigned_long__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "OrthPoly_an_set" "', argument " "2"" of type '" "double (*)(size_t)""'"); 
    }
  }
  if (arg1) (arg1)->an = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_an_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double (*result)(size_t) = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPoly_an_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_an_get" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  result = (double (*)(size_t)) ((arg1)->an);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_unsigned_long__double);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_bn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  double (*arg2)(size_t) = (double (*)(size_t)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPoly_bn_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_bn_set" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_unsigned_long__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "OrthPoly_bn_set" "', argument " "2"" of type '" "double (*)(size_t)""'"); 
    }
  }
  if (arg1) (arg1)->bn = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_bn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double (*result)(size_t) = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPoly_bn_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_bn_get" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  result = (double (*)(size_t)) ((arg1)->bn);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_unsigned_long__double);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_cn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  double (*arg2)(size_t) = (double (*)(size_t)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPoly_cn_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_cn_set" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_unsigned_long__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "OrthPoly_cn_set" "', argument " "2"" of type '" "double (*)(size_t)""'"); 
    }
  }
  if (arg1) (arg1)->cn = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_cn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double (*result)(size_t) = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPoly_cn_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_cn_get" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  result = (double (*)(size_t)) ((arg1)->cn);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_unsigned_long__double);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_lower_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPoly_lower_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_lower_set" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthPoly_lower_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->lower = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_lower_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPoly_lower_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_lower_get" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  result = (double) ((arg1)->lower);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_upper_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPoly_upper_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_upper_set" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthPoly_upper_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->upper = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_upper_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPoly_upper_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_upper_get" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  result = (double) ((arg1)->upper);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_const_term_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPoly_const_term_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_const_term_set" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthPoly_const_term_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->const_term = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_const_term_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPoly_const_term_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_const_term_get" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  result = (double) ((arg1)->const_term);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_lin_coeff_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPoly_lin_coeff_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_lin_coeff_set" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthPoly_lin_coeff_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->lin_coeff = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_lin_coeff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPoly_lin_coeff_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_lin_coeff_get" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  result = (double) ((arg1)->lin_coeff);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_lin_const_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPoly_lin_const_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_lin_const_set" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthPoly_lin_const_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->lin_const = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_lin_const_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPoly_lin_const_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_lin_const_get" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  result = (double) ((arg1)->lin_const);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_norm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  double (*arg2)(size_t) = (double (*)(size_t)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPoly_norm_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_norm_set" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_unsigned_long__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "OrthPoly_norm_set" "', argument " "2"" of type '" "double (*)(size_t)""'"); 
    }
  }
  if (arg1) (arg1)->norm = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPoly_norm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double (*result)(size_t) = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPoly_norm_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPoly_norm_get" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  result = (double (*)(size_t)) ((arg1)->norm);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_unsigned_long__double);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrthPoly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrthPoly")) SWIG_fail;
  result = (struct OrthPoly *)calloc(1, sizeof(struct OrthPoly));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPoly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OrthPoly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrthPoly",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrthPoly" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_init_cheb_poly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":init_cheb_poly")) SWIG_fail;
  result = (struct OrthPoly *)init_cheb_poly();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_init_leg_poly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":init_leg_poly")) SWIG_fail;
  result = (struct OrthPoly *)init_leg_poly();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_free_orth_poly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:free_orth_poly",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "free_orth_poly" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  free_orth_poly(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_serialize_orth_poly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:serialize_orth_poly",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "serialize_orth_poly" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  result = (unsigned char *)serialize_orth_poly(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_deserialize_orth_poly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct OrthPoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:deserialize_orth_poly",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deserialize_orth_poly" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  result = (struct OrthPoly *)deserialize_orth_poly(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_to_standard_poly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct StandardPoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_to_standard_poly",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_to_standard_poly" "', argument " "1"" of type '" "struct OrthPoly *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_to_standard_poly" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (struct StandardPoly *)orth_to_standard_poly(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StandardPoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_deriv_legen_upto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  size_t arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:deriv_legen_upto",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "deriv_legen_upto" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "deriv_legen_upto" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double *)deriv_legen_upto(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPoly *arg1 = (struct OrthPoly *) 0 ;
  size_t arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_eval",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_eval" "', argument " "1"" of type '" "struct OrthPoly const *""'"); 
  }
  arg1 = (struct OrthPoly *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_eval" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "orth_poly_eval" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  result = (double)orth_poly_eval((struct OrthPoly const *)arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_p_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  struct OrthPoly *arg2 = (struct OrthPoly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPolyExpansion_p_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_p_set" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OrthPoly, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OrthPolyExpansion_p_set" "', argument " "2"" of type '" "struct OrthPoly *""'"); 
  }
  arg2 = (struct OrthPoly *)(argp2);
  if (arg1) (arg1)->p = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_p_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct OrthPoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPolyExpansion_p_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_p_get" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (struct OrthPoly *) ((arg1)->p);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_num_poly_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPolyExpansion_num_poly_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_num_poly_set" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthPolyExpansion_num_poly_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->num_poly = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_num_poly_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPolyExpansion_num_poly_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_num_poly_get" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (size_t) ((arg1)->num_poly);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_lower_bound_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPolyExpansion_lower_bound_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_lower_bound_set" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthPolyExpansion_lower_bound_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->lower_bound = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_lower_bound_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPolyExpansion_lower_bound_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_lower_bound_get" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (double) ((arg1)->lower_bound);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_upper_bound_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPolyExpansion_upper_bound_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_upper_bound_set" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthPolyExpansion_upper_bound_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->upper_bound = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_upper_bound_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPolyExpansion_upper_bound_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_upper_bound_get" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (double) ((arg1)->upper_bound);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_coeff_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPolyExpansion_coeff_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_coeff_set" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OrthPolyExpansion_coeff_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->coeff = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_coeff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPolyExpansion_coeff_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_coeff_get" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (double *) ((arg1)->coeff);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_ccoeff_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double complex *arg2 = (double complex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPolyExpansion_ccoeff_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_ccoeff_set" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double_complex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OrthPolyExpansion_ccoeff_set" "', argument " "2"" of type '" "double complex *""'"); 
  }
  arg2 = (double complex *)(argp2);
  if (arg1) (arg1)->ccoeff = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_ccoeff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double complex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPolyExpansion_ccoeff_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_ccoeff_get" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (double complex *) ((arg1)->ccoeff);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double_complex, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_nalloc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPolyExpansion_nalloc_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_nalloc_set" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthPolyExpansion_nalloc_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->nalloc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_nalloc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPolyExpansion_nalloc_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_nalloc_get" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (size_t) ((arg1)->nalloc);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_space_transform_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  struct SpaceMapping *arg2 = (struct SpaceMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPolyExpansion_space_transform_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_space_transform_set" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SpaceMapping, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OrthPolyExpansion_space_transform_set" "', argument " "2"" of type '" "struct SpaceMapping *""'"); 
  }
  arg2 = (struct SpaceMapping *)(argp2);
  if (arg1) (arg1)->space_transform = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_space_transform_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct SpaceMapping *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPolyExpansion_space_transform_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_space_transform_get" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (struct SpaceMapping *) ((arg1)->space_transform);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpaceMapping, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_kristoffel_eval_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OrthPolyExpansion_kristoffel_eval_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_kristoffel_eval_set" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthPolyExpansion_kristoffel_eval_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->kristoffel_eval = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrthPolyExpansion_kristoffel_eval_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OrthPolyExpansion_kristoffel_eval_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthPolyExpansion_kristoffel_eval_get" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (int) ((arg1)->kristoffel_eval);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrthPolyExpansion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrthPolyExpansion")) SWIG_fail;
  result = (struct OrthPolyExpansion *)calloc(1, sizeof(struct OrthPolyExpansion));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OrthPolyExpansion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrthPolyExpansion",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrthPolyExpansion" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_orth_poly_expansion_get_num_poly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_get_num_poly",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_get_num_poly" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (size_t)orth_poly_expansion_get_num_poly((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_get_num_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_get_num_params",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_get_num_params" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (size_t)orth_poly_expansion_get_num_params((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_get_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_get_lb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_get_lb" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (double)orth_poly_expansion_get_lb((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_get_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_get_ub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_get_ub" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (double)orth_poly_expansion_get_ub((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum poly_type arg1 ;
  size_t arg2 ;
  double arg3 ;
  double arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:orth_poly_expansion_init",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_init" "', argument " "1"" of type '" "enum poly_type""'");
  } 
  arg1 = (enum poly_type)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_init" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "orth_poly_expansion_init" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "orth_poly_expansion_init" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_init(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_init_from_opts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_init_from_opts",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_init_from_opts" "', argument " "1"" of type '" "struct OpeOpts const *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_init_from_opts" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_init_from_opts((struct OpeOpts const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_create_with_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_expansion_create_with_params",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_create_with_params" "', argument " "1"" of type '" "struct OpeOpts *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_create_with_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_create_with_params" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_create_with_params(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_get_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_get_params",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_get_params" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_get_params" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (size_t)orth_poly_expansion_get_params((struct OrthPolyExpansion const *)arg1,arg2);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_get_params_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_get_params_ref",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_get_params_ref" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_get_params_ref" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (double *)orth_poly_expansion_get_params_ref((struct OrthPolyExpansion const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_update_params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_expansion_update_params",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_update_params" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_update_params" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_update_params" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (int)orth_poly_expansion_update_params(arg1,arg2,(double const *)arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_copy" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_copy((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_get_ptype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum poly_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_get_ptype",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_get_ptype" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (enum poly_type)orth_poly_expansion_get_ptype((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_zero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_zero",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_zero" "', argument " "1"" of type '" "struct OpeOpts *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_zero" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_zero(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_constant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct OpeOpts *arg2 = (struct OpeOpts *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_constant",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_constant" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_constant" "', argument " "2"" of type '" "struct OpeOpts *""'"); 
  }
  arg2 = (struct OpeOpts *)(argp2);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_constant(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_linear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  struct OpeOpts *arg3 = (struct OpeOpts *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_expansion_linear",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_linear" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_linear" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_linear" "', argument " "3"" of type '" "struct OpeOpts *""'"); 
  }
  arg3 = (struct OpeOpts *)(argp3);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_linear(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_linear_update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_expansion_linear_update",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_linear_update" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_linear_update" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "orth_poly_expansion_linear_update" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  result = (int)orth_poly_expansion_linear_update(arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_quadratic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  struct OpeOpts *arg3 = (struct OpeOpts *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_expansion_quadratic",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_quadratic" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_quadratic" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_quadratic" "', argument " "3"" of type '" "struct OpeOpts *""'"); 
  }
  arg3 = (struct OpeOpts *)(argp3);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_quadratic(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_genorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct OpeOpts *arg2 = (struct OpeOpts *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_genorder",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_genorder" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_genorder" "', argument " "2"" of type '" "struct OpeOpts *""'"); 
  }
  arg2 = (struct OpeOpts *)(argp2);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_genorder(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_orth_basis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct OrthPolyExpansion **arg2 = (struct OrthPolyExpansion **) 0 ;
  struct OpeOpts *arg3 = (struct OpeOpts *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_expansion_orth_basis",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_orth_basis" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_orth_basis" "', argument " "2"" of type '" "struct OrthPolyExpansion **""'"); 
  }
  arg2 = (struct OrthPolyExpansion **)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_orth_basis" "', argument " "3"" of type '" "struct OpeOpts *""'"); 
  }
  arg3 = (struct OpeOpts *)(argp3);
  orth_poly_expansion_orth_basis(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_deriv_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_deriv_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_deriv_eval" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_deriv_eval" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)orth_poly_expansion_deriv_eval((struct OrthPolyExpansion const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_deriv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_deriv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_deriv" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_deriv((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_dderiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_dderiv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_dderiv" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_dderiv((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_dderiv_periodic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_dderiv_periodic",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_dderiv_periodic" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_dderiv_periodic((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_free" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  orth_poly_expansion_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_serialize_orth_poly_expansion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct OrthPolyExpansion *arg2 = (struct OrthPolyExpansion *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:serialize_orth_poly_expansion",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "serialize_orth_poly_expansion" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "serialize_orth_poly_expansion" "', argument " "2"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg2 = (struct OrthPolyExpansion *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "serialize_orth_poly_expansion" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (unsigned char *)serialize_orth_poly_expansion(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_deserialize_orth_poly_expansion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct OrthPolyExpansion **arg2 = (struct OrthPolyExpansion **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:deserialize_orth_poly_expansion",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deserialize_orth_poly_expansion" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "deserialize_orth_poly_expansion" "', argument " "2"" of type '" "struct OrthPolyExpansion **""'"); 
  }
  arg2 = (struct OrthPolyExpansion **)(argp2);
  result = (unsigned char *)deserialize_orth_poly_expansion(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_savetxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_expansion_savetxt",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_savetxt" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_savetxt" "', argument " "2"" of type '" "FILE *""'"); 
  }
  arg2 = (FILE *)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "orth_poly_expansion_savetxt" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  orth_poly_expansion_savetxt((struct OrthPolyExpansion const *)arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_loadtxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FILE *arg1 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_loadtxt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_loadtxt" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = (FILE *)(argp1);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_loadtxt(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_to_standard_poly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct StandardPoly *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_to_standard_poly",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_to_standard_poly" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (struct StandardPoly *)orth_poly_expansion_to_standard_poly(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StandardPoly, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_arr_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct OrthPolyExpansion **arg2 = (struct OrthPolyExpansion **) 0 ;
  double arg3 ;
  double *arg4 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:orth_poly_expansion_arr_eval",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_arr_eval" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_arr_eval" "', argument " "2"" of type '" "struct OrthPolyExpansion **""'"); 
  }
  arg2 = (struct OrthPolyExpansion **)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "orth_poly_expansion_arr_eval" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "orth_poly_expansion_arr_eval" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (int)orth_poly_expansion_arr_eval(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_arr_evalN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  struct OrthPolyExpansion **arg2 = (struct OrthPolyExpansion **) 0 ;
  size_t arg3 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  double *arg6 = (double *) 0 ;
  size_t arg7 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:orth_poly_expansion_arr_evalN",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_arr_evalN" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_arr_evalN" "', argument " "2"" of type '" "struct OrthPolyExpansion **""'"); 
  }
  arg2 = (struct OrthPolyExpansion **)(argp2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "orth_poly_expansion_arr_evalN" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "orth_poly_expansion_arr_evalN" "', argument " "4"" of type '" "double const *""'"); 
  }
  arg4 = (double *)(argp4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "orth_poly_expansion_arr_evalN" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "orth_poly_expansion_arr_evalN" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  ecode7 = SWIG_AsVal_size_t(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "orth_poly_expansion_arr_evalN" "', argument " "7"" of type '" "size_t""'");
  } 
  arg7 = (size_t)(val7);
  result = (int)orth_poly_expansion_arr_evalN(arg1,arg2,arg3,(double const *)arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_chebyshev_poly_expansion_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:chebyshev_poly_expansion_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "chebyshev_poly_expansion_eval" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "chebyshev_poly_expansion_eval" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)chebyshev_poly_expansion_eval((struct OrthPolyExpansion const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_eval" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_eval" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)orth_poly_expansion_eval((struct OrthPolyExpansion const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_get_kristoffel_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_get_kristoffel_weight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_get_kristoffel_weight" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_get_kristoffel_weight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double)orth_poly_expansion_get_kristoffel_weight((struct OrthPolyExpansion const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_evalN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:orth_poly_expansion_evalN",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_evalN" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_evalN" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_evalN" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "orth_poly_expansion_evalN" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "orth_poly_expansion_evalN" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "orth_poly_expansion_evalN" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  orth_poly_expansion_evalN((struct OrthPolyExpansion const *)arg1,arg2,(double const *)arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_param_grad_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:orth_poly_expansion_param_grad_eval",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_param_grad_eval" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_param_grad_eval" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_param_grad_eval" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "orth_poly_expansion_param_grad_eval" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (int)orth_poly_expansion_param_grad_eval((struct OrthPolyExpansion const *)arg1,arg2,(double const *)arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_param_grad_eval2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_expansion_param_grad_eval2",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_param_grad_eval2" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_param_grad_eval2" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_param_grad_eval2" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (double)orth_poly_expansion_param_grad_eval2((struct OrthPolyExpansion const *)arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_squared_norm_param_grad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_expansion_squared_norm_param_grad",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_squared_norm_param_grad" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_squared_norm_param_grad" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_squared_norm_param_grad" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (int)orth_poly_expansion_squared_norm_param_grad((struct OrthPolyExpansion const *)arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_rkhs_squared_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  enum coeff_decay_type arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_expansion_rkhs_squared_norm",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_rkhs_squared_norm" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_rkhs_squared_norm" "', argument " "2"" of type '" "enum coeff_decay_type""'");
  } 
  arg2 = (enum coeff_decay_type)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "orth_poly_expansion_rkhs_squared_norm" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  result = (double)orth_poly_expansion_rkhs_squared_norm((struct OrthPolyExpansion const *)arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_rkhs_squared_norm_param_grad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double arg2 ;
  enum coeff_decay_type arg3 ;
  double arg4 ;
  double *arg5 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:orth_poly_expansion_rkhs_squared_norm_param_grad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_rkhs_squared_norm_param_grad" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_rkhs_squared_norm_param_grad" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "orth_poly_expansion_rkhs_squared_norm_param_grad" "', argument " "3"" of type '" "enum coeff_decay_type""'");
  } 
  arg3 = (enum coeff_decay_type)(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "orth_poly_expansion_rkhs_squared_norm_param_grad" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "orth_poly_expansion_rkhs_squared_norm_param_grad" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  result = (int)orth_poly_expansion_rkhs_squared_norm_param_grad((struct OrthPolyExpansion const *)arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_round(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion **arg1 = (struct OrthPolyExpansion **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_round",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_round" "', argument " "1"" of type '" "struct OrthPolyExpansion **""'"); 
  }
  arg1 = (struct OrthPolyExpansion **)(argp1);
  orth_poly_expansion_round(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_roundt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion **arg1 = (struct OrthPolyExpansion **) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_roundt",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_roundt" "', argument " "1"" of type '" "struct OrthPolyExpansion **""'"); 
  }
  arg1 = (struct OrthPolyExpansion **)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_roundt" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  orth_poly_expansion_roundt(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_approx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double (*arg1)(double,void *) = (double (*)(double,void *)) 0 ;
  void *arg2 = (void *) 0 ;
  struct OrthPolyExpansion *arg3 = (struct OrthPolyExpansion *) 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_expansion_approx",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "orth_poly_expansion_approx" "', argument " "1"" of type '" "double (*)(double,void *)""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_approx" "', argument " "2"" of type '" "void *""'"); 
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_approx" "', argument " "3"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg3 = (struct OrthPolyExpansion *)(argp3);
  orth_poly_expansion_approx(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_approx_vec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  struct Fwrap *arg2 = (struct Fwrap *) 0 ;
  struct OpeOpts *arg3 = (struct OpeOpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_expansion_approx_vec",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_approx_vec" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_approx_vec" "', argument " "2"" of type '" "struct Fwrap *""'"); 
  }
  arg2 = (struct Fwrap *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_approx_vec" "', argument " "3"" of type '" "struct OpeOpts const *""'"); 
  }
  arg3 = (struct OpeOpts *)(argp3);
  result = (int)orth_poly_expansion_approx_vec(arg1,arg2,(struct OpeOpts const *)arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_approx_adapt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OpeOpts *arg1 = (struct OpeOpts *) 0 ;
  struct Fwrap *arg2 = (struct Fwrap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_approx_adapt",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpeOpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_approx_adapt" "', argument " "1"" of type '" "struct OpeOpts const *""'"); 
  }
  arg1 = (struct OpeOpts *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fwrap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_approx_adapt" "', argument " "2"" of type '" "struct Fwrap *""'"); 
  }
  arg2 = (struct Fwrap *)(argp2);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_approx_adapt((struct OpeOpts const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_randu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum poly_type arg1 ;
  size_t arg2 ;
  double arg3 ;
  double arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:orth_poly_expansion_randu",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_randu" "', argument " "1"" of type '" "enum poly_type""'");
  } 
  arg1 = (enum poly_type)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_randu" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "orth_poly_expansion_randu" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "orth_poly_expansion_randu" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_randu(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cheb_integrate2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:cheb_integrate2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cheb_integrate2" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (double)cheb_integrate2((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_legendre_integrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:legendre_integrate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendre_integrate" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (double)legendre_integrate((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_prod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  struct OrthPolyExpansion *arg2 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_prod",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_prod" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_prod" "', argument " "2"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg2 = (struct OrthPolyExpansion *)(argp2);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_prod((struct OrthPolyExpansion const *)arg1,(struct OrthPolyExpansion const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_sum_prod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct OrthPolyExpansion **arg3 = (struct OrthPolyExpansion **) 0 ;
  size_t arg4 ;
  struct OrthPolyExpansion **arg5 = (struct OrthPolyExpansion **) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:orth_poly_expansion_sum_prod",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_sum_prod" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_sum_prod" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_sum_prod" "', argument " "3"" of type '" "struct OrthPolyExpansion **""'"); 
  }
  arg3 = (struct OrthPolyExpansion **)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "orth_poly_expansion_sum_prod" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "orth_poly_expansion_sum_prod" "', argument " "5"" of type '" "struct OrthPolyExpansion **""'"); 
  }
  arg5 = (struct OrthPolyExpansion **)(argp5);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_sum_prod(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_integrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_integrate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_integrate" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (double)orth_poly_expansion_integrate((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_integrate_weighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_integrate_weighted",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_integrate_weighted" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (double)orth_poly_expansion_integrate_weighted((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_inner_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  struct OrthPolyExpansion *arg2 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_inner_w",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_inner_w" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_inner_w" "', argument " "2"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg2 = (struct OrthPolyExpansion *)(argp2);
  result = (double)orth_poly_expansion_inner_w((struct OrthPolyExpansion const *)arg1,(struct OrthPolyExpansion const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_inner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  struct OrthPolyExpansion *arg2 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_inner",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_inner" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_inner" "', argument " "2"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg2 = (struct OrthPolyExpansion *)(argp2);
  result = (double)orth_poly_expansion_inner((struct OrthPolyExpansion const *)arg1,(struct OrthPolyExpansion const *)arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_norm_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_norm_w",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_norm_w" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (double)orth_poly_expansion_norm_w((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_norm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_norm" "', argument " "1"" of type '" "struct OrthPolyExpansion const *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  result = (double)orth_poly_expansion_norm((struct OrthPolyExpansion const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_flip_sign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:orth_poly_expansion_flip_sign",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_flip_sign" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  orth_poly_expansion_flip_sign(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct OrthPolyExpansion *arg2 = (struct OrthPolyExpansion *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_scale",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_scale" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_scale" "', argument " "2"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg2 = (struct OrthPolyExpansion *)(argp2);
  orth_poly_expansion_scale(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_daxpby(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct OrthPolyExpansion *arg2 = (struct OrthPolyExpansion *) 0 ;
  double arg3 ;
  struct OrthPolyExpansion *arg4 = (struct OrthPolyExpansion *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:orth_poly_expansion_daxpby",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_daxpby" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_daxpby" "', argument " "2"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg2 = (struct OrthPolyExpansion *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "orth_poly_expansion_daxpby" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "orth_poly_expansion_daxpby" "', argument " "4"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg4 = (struct OrthPolyExpansion *)(argp4);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_daxpby(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_axpy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct OrthPolyExpansion *arg2 = (struct OrthPolyExpansion *) 0 ;
  struct OrthPolyExpansion *arg3 = (struct OrthPolyExpansion *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_expansion_axpy",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_axpy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_axpy" "', argument " "2"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg2 = (struct OrthPolyExpansion *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_axpy" "', argument " "3"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg3 = (struct OrthPolyExpansion *)(argp3);
  result = (int)orth_poly_expansion_axpy(arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_sum3_up(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  struct OrthPolyExpansion *arg2 = (struct OrthPolyExpansion *) 0 ;
  double arg3 ;
  struct OrthPolyExpansion *arg4 = (struct OrthPolyExpansion *) 0 ;
  double arg5 ;
  struct OrthPolyExpansion *arg6 = (struct OrthPolyExpansion *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:orth_poly_expansion_sum3_up",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_sum3_up" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_sum3_up" "', argument " "2"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg2 = (struct OrthPolyExpansion *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "orth_poly_expansion_sum3_up" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "orth_poly_expansion_sum3_up" "', argument " "4"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg4 = (struct OrthPolyExpansion *)(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "orth_poly_expansion_sum3_up" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "orth_poly_expansion_sum3_up" "', argument " "6"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg6 = (struct OrthPolyExpansion *)(argp6);
  orth_poly_expansion_sum3_up(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_lin_comb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  struct OrthPolyExpansion **arg3 = (struct OrthPolyExpansion **) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  struct OrthPolyExpansion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:orth_poly_expansion_lin_comb",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orth_poly_expansion_lin_comb" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "orth_poly_expansion_lin_comb" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_lin_comb" "', argument " "3"" of type '" "struct OrthPolyExpansion **""'"); 
  }
  arg3 = (struct OrthPolyExpansion **)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "orth_poly_expansion_lin_comb" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "orth_poly_expansion_lin_comb" "', argument " "5"" of type '" "double const *""'"); 
  }
  arg5 = (double *)(argp5);
  result = (struct OrthPolyExpansion *)orth_poly_expansion_lin_comb(arg1,arg2,arg3,arg4,(double const *)arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_legendre_expansion_real_roots(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:legendre_expansion_real_roots",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendre_expansion_real_roots" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "legendre_expansion_real_roots" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (double *)legendre_expansion_real_roots(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_standard_poly_real_roots(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct StandardPoly *arg1 = (struct StandardPoly *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:standard_poly_real_roots",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StandardPoly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "standard_poly_real_roots" "', argument " "1"" of type '" "struct StandardPoly *""'"); 
  }
  arg1 = (struct StandardPoly *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "standard_poly_real_roots" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (double *)standard_poly_real_roots(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_real_roots(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_real_roots",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_real_roots" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_real_roots" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  result = (double *)orth_poly_expansion_real_roots(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_max",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_max" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_max" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (double)orth_poly_expansion_max(arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:orth_poly_expansion_min",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_min" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_min" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (double)orth_poly_expansion_min(arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_orth_poly_expansion_absmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  double *arg2 = (double *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:orth_poly_expansion_absmax",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "orth_poly_expansion_absmax" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "orth_poly_expansion_absmax" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orth_poly_expansion_absmax" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (double)orth_poly_expansion_absmax(arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_orth_poly_expansion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct OrthPolyExpansion *arg1 = (struct OrthPolyExpansion *) 0 ;
  size_t arg2 ;
  void *arg3 = (void *) 0 ;
  FILE *arg4 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:print_orth_poly_expansion",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OrthPolyExpansion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_orth_poly_expansion" "', argument " "1"" of type '" "struct OrthPolyExpansion *""'"); 
  }
  arg1 = (struct OrthPolyExpansion *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "print_orth_poly_expansion" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "print_orth_poly_expansion" "', argument " "3"" of type '" "void *""'"); 
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "print_orth_poly_expansion" "', argument " "4"" of type '" "FILE *""'"); 
  }
  arg4 = (FILE *)(argp4);
  print_orth_poly_expansion(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bounding_box_init_std(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct BoundingBox *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:bounding_box_init_std",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bounding_box_init_std" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct BoundingBox *)bounding_box_init_std(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BoundingBox, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bounding_box_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double arg2 ;
  double arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct BoundingBox *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:bounding_box_init",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bounding_box_init" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bounding_box_init" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "bounding_box_init" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  result = (struct BoundingBox *)bounding_box_init(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BoundingBox, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bounding_box_vec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct BoundingBox *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:bounding_box_vec",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bounding_box_vec" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bounding_box_vec" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bounding_box_vec" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (struct BoundingBox *)bounding_box_vec(arg1,(double const *)arg2,(double const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BoundingBox, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bounding_box_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct BoundingBox *arg1 = (struct BoundingBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:bounding_box_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bounding_box_free" "', argument " "1"" of type '" "struct BoundingBox *""'"); 
  }
  arg1 = (struct BoundingBox *)(argp1);
  bounding_box_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bounding_box_get_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct BoundingBox *arg1 = (struct BoundingBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:bounding_box_get_dim",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bounding_box_get_dim" "', argument " "1"" of type '" "struct BoundingBox const *""'"); 
  }
  arg1 = (struct BoundingBox *)(argp1);
  result = (size_t)bounding_box_get_dim((struct BoundingBox const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bounding_box_get_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct BoundingBox *arg1 = (struct BoundingBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:bounding_box_get_lb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bounding_box_get_lb" "', argument " "1"" of type '" "struct BoundingBox const *""'"); 
  }
  arg1 = (struct BoundingBox *)(argp1);
  result = (double *)bounding_box_get_lb((struct BoundingBox const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bounding_box_get_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct BoundingBox *arg1 = (struct BoundingBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:bounding_box_get_ub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bounding_box_get_ub" "', argument " "1"" of type '" "struct BoundingBox const *""'"); 
  }
  arg1 = (struct BoundingBox *)(argp1);
  result = (double *)bounding_box_get_ub((struct BoundingBox const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bounding_box_get_ub_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct BoundingBox *arg1 = (struct BoundingBox *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:bounding_box_get_ub_dim",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bounding_box_get_ub_dim" "', argument " "1"" of type '" "struct BoundingBox const *""'"); 
  }
  arg1 = (struct BoundingBox *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bounding_box_get_ub_dim" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double)bounding_box_get_ub_dim((struct BoundingBox const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bounding_box_set_ub_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct BoundingBox *arg1 = (struct BoundingBox *) 0 ;
  size_t arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:bounding_box_set_ub_dim",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bounding_box_set_ub_dim" "', argument " "1"" of type '" "struct BoundingBox *""'"); 
  }
  arg1 = (struct BoundingBox *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bounding_box_set_ub_dim" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "bounding_box_set_ub_dim" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  bounding_box_set_ub_dim(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bounding_box_get_lb_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct BoundingBox *arg1 = (struct BoundingBox *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:bounding_box_get_lb_dim",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bounding_box_get_lb_dim" "', argument " "1"" of type '" "struct BoundingBox const *""'"); 
  }
  arg1 = (struct BoundingBox *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bounding_box_get_lb_dim" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double)bounding_box_get_lb_dim((struct BoundingBox const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bounding_box_set_lb_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct BoundingBox *arg1 = (struct BoundingBox *) 0 ;
  size_t arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:bounding_box_set_lb_dim",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bounding_box_set_lb_dim" "', argument " "1"" of type '" "struct BoundingBox *""'"); 
  }
  arg1 = (struct BoundingBox *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bounding_box_set_lb_dim" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "bounding_box_set_lb_dim" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  bounding_box_set_lb_dim(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dgetri_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) 0 ;
  double *arg2 = (double *) 0 ;
  int *arg3 = (int *) 0 ;
  int *arg4 = (int *) 0 ;
  double *arg5 = (double *) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:dgetri_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dgetri_" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = (int *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dgetri_" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dgetri_" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dgetri_" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dgetri_" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dgetri_" "', argument " "6"" of type '" "int *""'"); 
  }
  arg6 = (int *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dgetri_" "', argument " "7"" of type '" "int *""'"); 
  }
  arg7 = (int *)(argp7);
  dgetri_(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dgetrf_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) 0 ;
  int *arg2 = (int *) 0 ;
  double *arg3 = (double *) 0 ;
  int *arg4 = (int *) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:dgetrf_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dgetrf_" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = (int *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dgetrf_" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dgetrf_" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dgetrf_" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dgetrf_" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dgetrf_" "', argument " "6"" of type '" "int *""'"); 
  }
  arg6 = (int *)(argp6);
  dgetrf_(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dorgqr_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  double *arg4 = (double *) 0 ;
  int *arg5 = (int *) 0 ;
  double *arg6 = (double *) 0 ;
  double *arg7 = (double *) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:dorgqr_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dorgqr_" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = (int *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dorgqr_" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dorgqr_" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dorgqr_" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dorgqr_" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dorgqr_" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dorgqr_" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dorgqr_" "', argument " "8"" of type '" "int *""'"); 
  }
  arg8 = (int *)(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "dorgqr_" "', argument " "9"" of type '" "int *""'"); 
  }
  arg9 = (int *)(argp9);
  dorgqr_(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dgeqrf_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) 0 ;
  int *arg2 = (int *) 0 ;
  double *arg3 = (double *) 0 ;
  int *arg4 = (int *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:dgeqrf_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dgeqrf_" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = (int *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dgeqrf_" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dgeqrf_" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dgeqrf_" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dgeqrf_" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dgeqrf_" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dgeqrf_" "', argument " "7"" of type '" "int *""'"); 
  }
  arg7 = (int *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dgeqrf_" "', argument " "8"" of type '" "int *""'"); 
  }
  arg8 = (int *)(argp8);
  dgeqrf_(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dgeev_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int *arg3 = (int *) 0 ;
  double *arg4 = (double *) 0 ;
  int *arg5 = (int *) 0 ;
  double *arg6 = (double *) 0 ;
  double *arg7 = (double *) 0 ;
  double *arg8 = (double *) 0 ;
  int *arg9 = (int *) 0 ;
  double *arg10 = (double *) 0 ;
  int *arg11 = (int *) 0 ;
  double *arg12 = (double *) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:dgeev_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dgeev_" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dgeev_" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dgeev_" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dgeev_" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dgeev_" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dgeev_" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dgeev_" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dgeev_" "', argument " "8"" of type '" "double *""'"); 
  }
  arg8 = (double *)(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "dgeev_" "', argument " "9"" of type '" "int *""'"); 
  }
  arg9 = (int *)(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "dgeev_" "', argument " "10"" of type '" "double *""'"); 
  }
  arg10 = (double *)(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "dgeev_" "', argument " "11"" of type '" "int *""'"); 
  }
  arg11 = (int *)(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "dgeev_" "', argument " "12"" of type '" "double *""'"); 
  }
  arg12 = (double *)(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "dgeev_" "', argument " "13"" of type '" "int *""'"); 
  }
  arg13 = (int *)(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "dgeev_" "', argument " "14"" of type '" "int *""'"); 
  }
  arg14 = (int *)(argp14);
  dgeev_(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dgebal_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int *arg2 = (int *) 0 ;
  double *arg3 = (double *) 0 ;
  int *arg4 = (int *) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  double *arg7 = (double *) 0 ;
  int *arg8 = (int *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:dgebal_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dgebal_" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dgebal_" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dgebal_" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dgebal_" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dgebal_" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dgebal_" "', argument " "6"" of type '" "int *""'"); 
  }
  arg6 = (int *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dgebal_" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dgebal_" "', argument " "8"" of type '" "int *""'"); 
  }
  arg8 = (int *)(argp8);
  dgebal_(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dhseqr_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int *arg3 = (int *) 0 ;
  int *arg4 = (int *) 0 ;
  int *arg5 = (int *) 0 ;
  double *arg6 = (double *) 0 ;
  int *arg7 = (int *) 0 ;
  double *arg8 = (double *) 0 ;
  double *arg9 = (double *) 0 ;
  double *arg10 = (double *) 0 ;
  int *arg11 = (int *) 0 ;
  double *arg12 = (double *) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:dhseqr_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dhseqr_" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dhseqr_" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dhseqr_" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dhseqr_" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dhseqr_" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dhseqr_" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dhseqr_" "', argument " "7"" of type '" "int *""'"); 
  }
  arg7 = (int *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dhseqr_" "', argument " "8"" of type '" "double *""'"); 
  }
  arg8 = (double *)(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "dhseqr_" "', argument " "9"" of type '" "double *""'"); 
  }
  arg9 = (double *)(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "dhseqr_" "', argument " "10"" of type '" "double *""'"); 
  }
  arg10 = (double *)(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "dhseqr_" "', argument " "11"" of type '" "int *""'"); 
  }
  arg11 = (int *)(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "dhseqr_" "', argument " "12"" of type '" "double *""'"); 
  }
  arg12 = (double *)(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "dhseqr_" "', argument " "13"" of type '" "int *""'"); 
  }
  arg13 = (int *)(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "dhseqr_" "', argument " "14"" of type '" "int *""'"); 
  }
  arg14 = (int *)(argp14);
  dhseqr_(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dorgrq_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  double *arg4 = (double *) 0 ;
  int *arg5 = (int *) 0 ;
  double *arg6 = (double *) 0 ;
  double *arg7 = (double *) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:dorgrq_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dorgrq_" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = (int *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dorgrq_" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dorgrq_" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dorgrq_" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dorgrq_" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dorgrq_" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dorgrq_" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dorgrq_" "', argument " "8"" of type '" "int *""'"); 
  }
  arg8 = (int *)(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "dorgrq_" "', argument " "9"" of type '" "int *""'"); 
  }
  arg9 = (int *)(argp9);
  dorgrq_(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dgerqf_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) 0 ;
  int *arg2 = (int *) 0 ;
  double *arg3 = (double *) 0 ;
  int *arg4 = (int *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:dgerqf_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dgerqf_" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = (int *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dgerqf_" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dgerqf_" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dgerqf_" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dgerqf_" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dgerqf_" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dgerqf_" "', argument " "7"" of type '" "int *""'"); 
  }
  arg7 = (int *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dgerqf_" "', argument " "8"" of type '" "int *""'"); 
  }
  arg8 = (int *)(argp8);
  dgerqf_(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dgesdd_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  double *arg4 = (double *) 0 ;
  int *arg5 = (int *) 0 ;
  double *arg6 = (double *) 0 ;
  double *arg7 = (double *) 0 ;
  int *arg8 = (int *) 0 ;
  double *arg9 = (double *) 0 ;
  int *arg10 = (int *) 0 ;
  double *arg11 = (double *) 0 ;
  int *arg12 = (int *) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:dgesdd_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dgesdd_" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dgesdd_" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dgesdd_" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dgesdd_" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dgesdd_" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dgesdd_" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dgesdd_" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dgesdd_" "', argument " "8"" of type '" "int *""'"); 
  }
  arg8 = (int *)(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "dgesdd_" "', argument " "9"" of type '" "double *""'"); 
  }
  arg9 = (double *)(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "dgesdd_" "', argument " "10"" of type '" "int *""'"); 
  }
  arg10 = (int *)(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "dgesdd_" "', argument " "11"" of type '" "double *""'"); 
  }
  arg11 = (double *)(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "dgesdd_" "', argument " "12"" of type '" "int *""'"); 
  }
  arg12 = (int *)(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "dgesdd_" "', argument " "13"" of type '" "int *""'"); 
  }
  arg13 = (int *)(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "dgesdd_" "', argument " "14"" of type '" "int *""'"); 
  }
  arg14 = (int *)(argp14);
  dgesdd_(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dstev_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int *arg2 = (int *) 0 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  int *arg6 = (int *) 0 ;
  double *arg7 = (double *) 0 ;
  int *arg8 = (int *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:dstev_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dstev_" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dstev_" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dstev_" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dstev_" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dstev_" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dstev_" "', argument " "6"" of type '" "int *""'"); 
  }
  arg6 = (int *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dstev_" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dstev_" "', argument " "8"" of type '" "int *""'"); 
  }
  arg8 = (int *)(argp8);
  dstev_(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dsyev_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int *arg3 = (int *) 0 ;
  double *arg4 = (double *) 0 ;
  int *arg5 = (int *) 0 ;
  double *arg6 = (double *) 0 ;
  double *arg7 = (double *) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:dsyev_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dsyev_" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dsyev_" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dsyev_" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dsyev_" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dsyev_" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dsyev_" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dsyev_" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dsyev_" "', argument " "8"" of type '" "int *""'"); 
  }
  arg8 = (int *)(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "dsyev_" "', argument " "9"" of type '" "int *""'"); 
  }
  arg9 = (int *)(argp9);
  dsyev_(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dpotrf_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int *arg2 = (int *) 0 ;
  double *arg3 = (double *) 0 ;
  int *arg4 = (int *) 0 ;
  int *arg5 = (int *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:dpotrf_",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dpotrf_" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dpotrf_" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dpotrf_" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dpotrf_" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dpotrf_" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  dpotrf_(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dpotri_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int *arg2 = (int *) 0 ;
  double *arg3 = (double *) 0 ;
  int *arg4 = (int *) 0 ;
  int *arg5 = (int *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:dpotri_",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dpotri_" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dpotri_" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dpotri_" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dpotri_" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dpotri_" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  dpotri_(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtrtri_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int *arg3 = (int *) 0 ;
  double *arg4 = (double *) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:dtrtri_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtrtri_" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dtrtri_" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtrtri_" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dtrtri_" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dtrtri_" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dtrtri_" "', argument " "6"" of type '" "int *""'"); 
  }
  arg6 = (int *)(argp6);
  dtrtri_(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dgesv_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) 0 ;
  int *arg2 = (int *) 0 ;
  double *arg3 = (double *) 0 ;
  int *arg4 = (int *) 0 ;
  int *arg5 = (int *) 0 ;
  double *arg6 = (double *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:dgesv_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dgesv_" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = (int *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dgesv_" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dgesv_" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dgesv_" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dgesv_" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dgesv_" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dgesv_" "', argument " "7"" of type '" "int *""'"); 
  }
  arg7 = (int *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dgesv_" "', argument " "8"" of type '" "int *""'"); 
  }
  arg8 = (int *)(argp8);
  dgesv_(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dgelsd_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  double *arg4 = (double *) 0 ;
  int *arg5 = (int *) 0 ;
  double *arg6 = (double *) 0 ;
  int *arg7 = (int *) 0 ;
  double *arg8 = (double *) 0 ;
  double *arg9 = (double *) 0 ;
  int *arg10 = (int *) 0 ;
  double *arg11 = (double *) 0 ;
  int *arg12 = (int *) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:dgelsd_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dgelsd_" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = (int *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dgelsd_" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dgelsd_" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dgelsd_" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dgelsd_" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dgelsd_" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dgelsd_" "', argument " "7"" of type '" "int *""'"); 
  }
  arg7 = (int *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dgelsd_" "', argument " "8"" of type '" "double *""'"); 
  }
  arg8 = (double *)(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "dgelsd_" "', argument " "9"" of type '" "double *""'"); 
  }
  arg9 = (double *)(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "dgelsd_" "', argument " "10"" of type '" "int *""'"); 
  }
  arg10 = (int *)(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "dgelsd_" "', argument " "11"" of type '" "double *""'"); 
  }
  arg11 = (double *)(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "dgelsd_" "', argument " "12"" of type '" "int *""'"); 
  }
  arg12 = (int *)(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "dgelsd_" "', argument " "13"" of type '" "int *""'"); 
  }
  arg13 = (int *)(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "dgelsd_" "', argument " "14"" of type '" "int *""'"); 
  }
  arg14 = (int *)(argp14);
  dgelsd_(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3linalg_multiple_vec_mat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  double *arg6 = (double *) 0 ;
  size_t arg7 ;
  double *arg8 = (double *) 0 ;
  size_t arg9 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:c3linalg_multiple_vec_mat",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3linalg_multiple_vec_mat" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3linalg_multiple_vec_mat" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c3linalg_multiple_vec_mat" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "c3linalg_multiple_vec_mat" "', argument " "4"" of type '" "double const *""'"); 
  }
  arg4 = (double *)(argp4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "c3linalg_multiple_vec_mat" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "c3linalg_multiple_vec_mat" "', argument " "6"" of type '" "double const *""'"); 
  }
  arg6 = (double *)(argp6);
  ecode7 = SWIG_AsVal_size_t(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "c3linalg_multiple_vec_mat" "', argument " "7"" of type '" "size_t""'");
  } 
  arg7 = (size_t)(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "c3linalg_multiple_vec_mat" "', argument " "8"" of type '" "double *""'"); 
  }
  arg8 = (double *)(argp8);
  ecode9 = SWIG_AsVal_size_t(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "c3linalg_multiple_vec_mat" "', argument " "9"" of type '" "size_t""'");
  } 
  arg9 = (size_t)(val9);
  c3linalg_multiple_vec_mat(arg1,arg2,arg3,(double const *)arg4,arg5,(double const *)arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3linalg_multiple_mat_vec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  double *arg6 = (double *) 0 ;
  size_t arg7 ;
  double *arg8 = (double *) 0 ;
  size_t arg9 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:c3linalg_multiple_mat_vec",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3linalg_multiple_mat_vec" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3linalg_multiple_mat_vec" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c3linalg_multiple_mat_vec" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "c3linalg_multiple_mat_vec" "', argument " "4"" of type '" "double const *""'"); 
  }
  arg4 = (double *)(argp4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "c3linalg_multiple_mat_vec" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "c3linalg_multiple_mat_vec" "', argument " "6"" of type '" "double const *""'"); 
  }
  arg6 = (double *)(argp6);
  ecode7 = SWIG_AsVal_size_t(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "c3linalg_multiple_mat_vec" "', argument " "7"" of type '" "size_t""'");
  } 
  arg7 = (size_t)(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "c3linalg_multiple_mat_vec" "', argument " "8"" of type '" "double *""'"); 
  }
  arg8 = (double *)(argp8);
  ecode9 = SWIG_AsVal_size_t(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "c3linalg_multiple_mat_vec" "', argument " "9"" of type '" "size_t""'");
  } 
  arg9 = (size_t)(val9);
  c3linalg_multiple_mat_vec(arg1,arg2,arg3,(double const *)arg4,arg5,(double const *)arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:qr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "qr" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qr" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "qr" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  result = (int)qr(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rq_with_rmult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  double *arg7 = (double *) 0 ;
  size_t arg8 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:rq_with_rmult",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "rq_with_rmult" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rq_with_rmult" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rq_with_rmult" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "rq_with_rmult" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "rq_with_rmult" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "rq_with_rmult" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "rq_with_rmult" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  ecode8 = SWIG_AsVal_size_t(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "rq_with_rmult" "', argument " "8"" of type '" "size_t""'");
  } 
  arg8 = (size_t)(val8);
  rq_with_rmult(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_svd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  double *arg7 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:svd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "svd" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "svd" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "svd" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "svd" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svd" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "svd" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "svd" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  svd(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_truncated_svd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  double *arg4 = (double *) 0 ;
  double **arg5 = (double **) 0 ;
  double **arg6 = (double **) 0 ;
  double **arg7 = (double **) 0 ;
  double arg8 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:truncated_svd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "truncated_svd" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "truncated_svd" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "truncated_svd" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "truncated_svd" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "truncated_svd" "', argument " "5"" of type '" "double **""'"); 
  }
  arg5 = (double **)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "truncated_svd" "', argument " "6"" of type '" "double **""'"); 
  }
  arg6 = (double **)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "truncated_svd" "', argument " "7"" of type '" "double **""'"); 
  }
  arg7 = (double **)(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "truncated_svd" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = (double)(val8);
  result = (size_t)truncated_svd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pinv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double arg6 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:pinv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pinv" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pinv" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pinv" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "pinv" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "pinv" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pinv" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = (double)(val6);
  result = (size_t)pinv(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:norm2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "norm2" "', argument " "1"" of type '" "double *""'"); 
  }
  arg1 = (double *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "norm2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  result = (double)norm2(arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm2diff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  double *arg2 = (double *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:norm2diff",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "norm2diff" "', argument " "1"" of type '" "double *""'"); 
  }
  arg1 = (double *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "norm2diff" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "norm2diff" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  result = (double)norm2diff(arg1,arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:mean",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mean" "', argument " "1"" of type '" "double *""'"); 
  }
  arg1 = (double *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mean" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double)mean(arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mean_size_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t *arg1 = (size_t *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:mean_size_t",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mean_size_t" "', argument " "1"" of type '" "size_t *""'"); 
  }
  arg1 = (size_t *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mean_size_t" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double)mean_size_t(arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct mat *arg1 = (struct mat *) 0 ;
  struct mat *arg2 = (struct mat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct mat *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:kron",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kron" "', argument " "1"" of type '" "struct mat const *""'"); 
  }
  arg1 = (struct mat *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kron" "', argument " "2"" of type '" "struct mat const *""'"); 
  }
  arg2 = (struct mat *)(argp2);
  result = (struct mat *)kron((struct mat const *)arg1,(struct mat const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kron_col(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double *arg3 = (double *) 0 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double *arg7 = (double *) 0 ;
  int arg8 ;
  double *arg9 = (double *) 0 ;
  int arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:kron_col",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "kron_col" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kron_col" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kron_col" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "kron_col" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "kron_col" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "kron_col" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "kron_col" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "kron_col" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = (int)(val8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "kron_col" "', argument " "9"" of type '" "double *""'"); 
  }
  arg9 = (double *)(argp9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "kron_col" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = (int)(val10);
  kron_col(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vec_kron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  double *arg7 = (double *) 0 ;
  size_t arg8 ;
  double *arg9 = (double *) 0 ;
  double arg10 ;
  double *arg11 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:vec_kron",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vec_kron" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vec_kron" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vec_kron" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vec_kron" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "vec_kron" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "vec_kron" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "vec_kron" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  ecode8 = SWIG_AsVal_size_t(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "vec_kron" "', argument " "8"" of type '" "size_t""'");
  } 
  arg8 = (size_t)(val8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "vec_kron" "', argument " "9"" of type '" "double *""'"); 
  }
  arg9 = (double *)(argp9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "vec_kron" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = (double)(val10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "vec_kron" "', argument " "11"" of type '" "double *""'"); 
  }
  arg11 = (double *)(argp11);
  vec_kron(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vec_kronl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  double *arg7 = (double *) 0 ;
  size_t arg8 ;
  long double *arg9 = (long double *) 0 ;
  double arg10 ;
  long double *arg11 = (long double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:vec_kronl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vec_kronl" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vec_kronl" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vec_kronl" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vec_kronl" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "vec_kronl" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  ecode6 = SWIG_AsVal_size_t(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "vec_kronl" "', argument " "6"" of type '" "size_t""'");
  } 
  arg6 = (size_t)(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "vec_kronl" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  ecode8 = SWIG_AsVal_size_t(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "vec_kronl" "', argument " "8"" of type '" "size_t""'");
  } 
  arg8 = (size_t)(val8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_long_double, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "vec_kronl" "', argument " "9"" of type '" "long double *""'"); 
  }
  arg9 = (long double *)(argp9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "vec_kronl" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = (double)(val10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_long_double, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "vec_kronl" "', argument " "11"" of type '" "long double *""'"); 
  }
  arg11 = (long double *)(argp11);
  vec_kronl(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_list_index_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_list *arg1 = (struct fiber_list *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fiber_list_index_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fiber_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fiber_list_index_set" "', argument " "1"" of type '" "struct fiber_list *""'"); 
  }
  arg1 = (struct fiber_list *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fiber_list_index_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_list_index_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_list *arg1 = (struct fiber_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:fiber_list_index_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fiber_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fiber_list_index_get" "', argument " "1"" of type '" "struct fiber_list *""'"); 
  }
  arg1 = (struct fiber_list *)(argp1);
  result = (size_t) ((arg1)->index);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_list_vals_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_list *arg1 = (struct fiber_list *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fiber_list_vals_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fiber_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fiber_list_vals_set" "', argument " "1"" of type '" "struct fiber_list *""'"); 
  }
  arg1 = (struct fiber_list *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fiber_list_vals_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->vals = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_list_vals_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_list *arg1 = (struct fiber_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:fiber_list_vals_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fiber_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fiber_list_vals_get" "', argument " "1"" of type '" "struct fiber_list *""'"); 
  }
  arg1 = (struct fiber_list *)(argp1);
  result = (double *) ((arg1)->vals);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_list_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_list *arg1 = (struct fiber_list *) 0 ;
  struct fiber_list *arg2 = (struct fiber_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fiber_list_next_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fiber_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fiber_list_next_set" "', argument " "1"" of type '" "struct fiber_list *""'"); 
  }
  arg1 = (struct fiber_list *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_fiber_list, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fiber_list_next_set" "', argument " "2"" of type '" "struct fiber_list *""'"); 
  }
  arg2 = (struct fiber_list *)(argp2);
  if (arg1) (arg1)->next = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_list_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_list *arg1 = (struct fiber_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct fiber_list *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:fiber_list_next_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fiber_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fiber_list_next_get" "', argument " "1"" of type '" "struct fiber_list *""'"); 
  }
  arg1 = (struct fiber_list *)(argp1);
  result = (struct fiber_list *) ((arg1)->next);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_fiber_list, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_fiber_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_list *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_fiber_list")) SWIG_fail;
  result = (struct fiber_list *)calloc(1, sizeof(struct fiber_list));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_fiber_list, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_fiber_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_list *arg1 = (struct fiber_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_fiber_list",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fiber_list, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_fiber_list" "', argument " "1"" of type '" "struct fiber_list *""'"); 
  }
  arg1 = (struct fiber_list *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_fiber_info_nfibers_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_info *arg1 = (struct fiber_info *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fiber_info_nfibers_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fiber_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fiber_info_nfibers_set" "', argument " "1"" of type '" "struct fiber_info *""'"); 
  }
  arg1 = (struct fiber_info *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fiber_info_nfibers_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->nfibers = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_info_nfibers_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_info *arg1 = (struct fiber_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:fiber_info_nfibers_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fiber_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fiber_info_nfibers_get" "', argument " "1"" of type '" "struct fiber_info *""'"); 
  }
  arg1 = (struct fiber_info *)(argp1);
  result = (size_t) ((arg1)->nfibers);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_info_head_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_info *arg1 = (struct fiber_info *) 0 ;
  struct fiber_list *arg2 = (struct fiber_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fiber_info_head_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fiber_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fiber_info_head_set" "', argument " "1"" of type '" "struct fiber_info *""'"); 
  }
  arg1 = (struct fiber_info *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_fiber_list, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fiber_info_head_set" "', argument " "2"" of type '" "struct fiber_list *""'"); 
  }
  arg2 = (struct fiber_list *)(argp2);
  if (arg1) (arg1)->head = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fiber_info_head_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_info *arg1 = (struct fiber_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct fiber_list *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:fiber_info_head_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fiber_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fiber_info_head_get" "', argument " "1"" of type '" "struct fiber_info *""'"); 
  }
  arg1 = (struct fiber_info *)(argp1);
  result = (struct fiber_list *) ((arg1)->head);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_fiber_list, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_fiber_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_fiber_info")) SWIG_fail;
  result = (struct fiber_info *)calloc(1, sizeof(struct fiber_info));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_fiber_info, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_fiber_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_info *arg1 = (struct fiber_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_fiber_info",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fiber_info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_fiber_info" "', argument " "1"" of type '" "struct fiber_info *""'"); 
  }
  arg1 = (struct fiber_info *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_AddFiber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_list **arg1 = (struct fiber_list **) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:AddFiber",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_fiber_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddFiber" "', argument " "1"" of type '" "struct fiber_list **""'"); 
  }
  arg1 = (struct fiber_list **)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AddFiber" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddFiber" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AddFiber" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  AddFiber(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexExists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_list *arg1 = (struct fiber_list *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:IndexExists",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fiber_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexExists" "', argument " "1"" of type '" "struct fiber_list *""'"); 
  }
  arg1 = (struct fiber_list *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndexExists" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (int)IndexExists(arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_getIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_list *arg1 = (struct fiber_list *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:getIndex",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fiber_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getIndex" "', argument " "1"" of type '" "struct fiber_list *""'"); 
  }
  arg1 = (struct fiber_list *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "getIndex" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double *)getIndex(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeleteFiberList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct fiber_list **arg1 = (struct fiber_list **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DeleteFiberList",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_fiber_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeleteFiberList" "', argument " "1"" of type '" "struct fiber_list **""'"); 
  }
  arg1 = (struct fiber_list **)(argp1);
  DeleteFiberList(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_n_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:sk_decomp_n_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_n_set" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sk_decomp_n_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->n = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_n_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:sk_decomp_n_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_n_get" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  result = (size_t) ((arg1)->n);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_m_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:sk_decomp_m_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_m_set" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sk_decomp_m_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->m = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_m_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:sk_decomp_m_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_m_get" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  result = (size_t) ((arg1)->m);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_rank_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:sk_decomp_rank_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_rank_set" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sk_decomp_rank_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->rank = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_rank_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:sk_decomp_rank_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_rank_get" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  result = (size_t) ((arg1)->rank);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_rows_kept_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:sk_decomp_rows_kept_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_rows_kept_set" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sk_decomp_rows_kept_set" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  if (arg1) (arg1)->rows_kept = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_rows_kept_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:sk_decomp_rows_kept_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_rows_kept_get" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  result = (size_t *) ((arg1)->rows_kept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_cols_kept_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:sk_decomp_cols_kept_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_cols_kept_set" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sk_decomp_cols_kept_set" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  if (arg1) (arg1)->cols_kept = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_cols_kept_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:sk_decomp_cols_kept_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_cols_kept_get" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  result = (size_t *) ((arg1)->cols_kept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_cross_rank_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:sk_decomp_cross_rank_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_cross_rank_set" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sk_decomp_cross_rank_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->cross_rank = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_cross_rank_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:sk_decomp_cross_rank_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_cross_rank_get" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  result = (size_t) ((arg1)->cross_rank);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_cross_inv_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:sk_decomp_cross_inv_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_cross_inv_set" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sk_decomp_cross_inv_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->cross_inv = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_cross_inv_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:sk_decomp_cross_inv_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_cross_inv_get" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  result = (double *) ((arg1)->cross_inv);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_row_vals_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  struct fiber_info *arg2 = (struct fiber_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:sk_decomp_row_vals_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_row_vals_set" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_fiber_info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sk_decomp_row_vals_set" "', argument " "2"" of type '" "struct fiber_info *""'"); 
  }
  arg2 = (struct fiber_info *)(argp2);
  if (arg1) (arg1)->row_vals = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_row_vals_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct fiber_info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:sk_decomp_row_vals_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_row_vals_get" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  result = (struct fiber_info *) ((arg1)->row_vals);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_fiber_info, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_col_vals_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  struct fiber_info *arg2 = (struct fiber_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:sk_decomp_col_vals_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_col_vals_set" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_fiber_info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sk_decomp_col_vals_set" "', argument " "2"" of type '" "struct fiber_info *""'"); 
  }
  arg2 = (struct fiber_info *)(argp2);
  if (arg1) (arg1)->col_vals = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_col_vals_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct fiber_info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:sk_decomp_col_vals_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_col_vals_get" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  result = (struct fiber_info *) ((arg1)->col_vals);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_fiber_info, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_success_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:sk_decomp_success_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_success_set" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sk_decomp_success_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->success = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_success_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:sk_decomp_success_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_success_get" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  result = (int) ((arg1)->success);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_sk_decomp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_sk_decomp")) SWIG_fail;
  result = (struct sk_decomp *)calloc(1, sizeof(struct sk_decomp));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sk_decomp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_sk_decomp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_sk_decomp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_sk_decomp" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_init_skf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp **arg1 = (struct sk_decomp **) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t 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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:init_skf",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "init_skf" "', argument " "1"" of type '" "struct sk_decomp **""'"); 
  }
  arg1 = (struct sk_decomp **)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "init_skf" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "init_skf" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "init_skf" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  init_skf(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sk_decomp_to_full(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp *arg1 = (struct sk_decomp *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:sk_decomp_to_full",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sk_decomp_to_full" "', argument " "1"" of type '" "struct sk_decomp *""'"); 
  }
  arg1 = (struct sk_decomp *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sk_decomp_to_full" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  sk_decomp_to_full(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_free_skf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct sk_decomp **arg1 = (struct sk_decomp **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:free_skf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "free_skf" "', argument " "1"" of type '" "struct sk_decomp **""'"); 
  }
  arg1 = (struct sk_decomp **)(argp1);
  free_skf(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_maxvol_rhs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  double *arg5 = (double *) 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 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:maxvol_rhs",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "maxvol_rhs" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = (double *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "maxvol_rhs" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "maxvol_rhs" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "maxvol_rhs" "', argument " "4"" of type '" "size_t *""'"); 
  }
  arg4 = (size_t *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "maxvol_rhs" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  result = (int)maxvol_rhs((double const *)arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_skeleton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t *arg5 = (size_t *) 0 ;
  size_t *arg6 = (size_t *) 0 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:skeleton",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "skeleton" "', argument " "1"" of type '" "double *""'"); 
  }
  arg1 = (double *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "skeleton" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "skeleton" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "skeleton" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "skeleton" "', argument " "5"" of type '" "size_t *""'"); 
  }
  arg5 = (size_t *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "skeleton" "', argument " "6"" of type '" "size_t *""'"); 
  }
  arg6 = (size_t *)(argp6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "skeleton" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = (double)(val7);
  result = (int)skeleton(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_skeleton_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double (*arg1)(int,int,int,void *) = (double (*)(int,int,int,void *)) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t *arg6 = (size_t *) 0 ;
  size_t *arg7 = (size_t *) 0 ;
  double arg8 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:skeleton_func",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_int_int_int_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "skeleton_func" "', argument " "1"" of type '" "double (*)(int,int,int,void *)""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "skeleton_func" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "skeleton_func" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "skeleton_func" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "skeleton_func" "', argument " "5"" of type '" "size_t""'");
  } 
  arg5 = (size_t)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "skeleton_func" "', argument " "6"" of type '" "size_t *""'"); 
  }
  arg6 = (size_t *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "skeleton_func" "', argument " "7"" of type '" "size_t *""'"); 
  }
  arg7 = (size_t *)(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "skeleton_func" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = (double)(val8);
  result = (int)skeleton_func(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_skeleton_func2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int (*arg1)(double *,double,size_t,size_t,double *,void *) = (int (*)(double *,double,size_t,size_t,double *,void *)) 0 ;
  void *arg2 = (void *) 0 ;
  struct sk_decomp **arg3 = (struct sk_decomp **) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double arg6 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:skeleton_func2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_p_double_double_unsigned_long_unsigned_long_p_double_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "skeleton_func2" "', argument " "1"" of type '" "int (*)(double *,double,size_t,size_t,double *,void *)""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "skeleton_func2" "', argument " "2"" of type '" "void *""'"); 
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_sk_decomp, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "skeleton_func2" "', argument " "3"" of type '" "struct sk_decomp **""'"); 
  }
  arg3 = (struct sk_decomp **)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "skeleton_func2" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "skeleton_func2" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "skeleton_func2" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = (double)(val6);
  result = (int)skeleton_func2(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_linear_ls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:linear_ls",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "linear_ls" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "linear_ls" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "linear_ls" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "linear_ls" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "linear_ls" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  linear_ls(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mat_nrows_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct mat *arg1 = (struct mat *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:mat_nrows_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mat_nrows_set" "', argument " "1"" of type '" "struct mat *""'"); 
  }
  arg1 = (struct mat *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mat_nrows_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->nrows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mat_nrows_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct mat *arg1 = (struct mat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:mat_nrows_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mat_nrows_get" "', argument " "1"" of type '" "struct mat *""'"); 
  }
  arg1 = (struct mat *)(argp1);
  result = (size_t) ((arg1)->nrows);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mat_ncols_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct mat *arg1 = (struct mat *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:mat_ncols_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mat_ncols_set" "', argument " "1"" of type '" "struct mat *""'"); 
  }
  arg1 = (struct mat *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mat_ncols_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->ncols = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mat_ncols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct mat *arg1 = (struct mat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:mat_ncols_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mat_ncols_get" "', argument " "1"" of type '" "struct mat *""'"); 
  }
  arg1 = (struct mat *)(argp1);
  result = (size_t) ((arg1)->ncols);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mat_vals_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct mat *arg1 = (struct mat *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:mat_vals_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mat_vals_set" "', argument " "1"" of type '" "struct mat *""'"); 
  }
  arg1 = (struct mat *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mat_vals_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->vals = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mat_vals_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct mat *arg1 = (struct mat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:mat_vals_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mat_vals_get" "', argument " "1"" of type '" "struct mat *""'"); 
  }
  arg1 = (struct mat *)(argp1);
  result = (double *) ((arg1)->vals);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_mat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct mat *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_mat")) SWIG_fail;
  result = (struct mat *)calloc(1, sizeof(struct mat));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_mat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct mat *arg1 = (struct mat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_mat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mat" "', argument " "1"" of type '" "struct mat *""'"); 
  }
  arg1 = (struct mat *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_v2m(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  int arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct mat *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:v2m",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "v2m" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "v2m" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "v2m" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  result = (struct mat *)v2m(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagv2m(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct mat *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:diagv2m",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "diagv2m" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "diagv2m" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (struct mat *)diagv2m(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_horizcat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct mat *arg1 = (struct mat *) 0 ;
  struct mat *arg2 = (struct mat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct mat *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:horizcat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "horizcat" "', argument " "1"" of type '" "struct mat const *""'"); 
  }
  arg1 = (struct mat *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "horizcat" "', argument " "2"" of type '" "struct mat const *""'"); 
  }
  arg2 = (struct mat *)(argp2);
  result = (struct mat *)horizcat((struct mat const *)arg1,(struct mat const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_block_diag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct mat **arg1 = (struct mat **) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct mat *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:block_diag",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_mat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "block_diag" "', argument " "1"" of type '" "struct mat const **""'"); 
  }
  arg1 = (struct mat **)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "block_diag" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (struct mat *)block_diag((struct mat const **)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_freemat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct mat *arg1 = (struct mat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:freemat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "freemat" "', argument " "1"" of type '" "struct mat *""'"); 
  }
  arg1 = (struct mat *)(argp1);
  freemat(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_printmat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct mat *arg1 = (struct mat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:printmat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printmat" "', argument " "1"" of type '" "struct mat *""'"); 
  }
  arg1 = (struct mat *)(argp1);
  printmat(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mat_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct mat *arg1 = (struct mat *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:mat_ones",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mat_ones" "', argument " "1"" of type '" "struct mat *""'"); 
  }
  arg1 = (struct mat *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mat_ones" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mat_ones" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  mat_ones(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum c3opt_alg arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct c3Opt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_create",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3opt_create" "', argument " "1"" of type '" "enum c3opt_alg""'");
  } 
  arg1 = (enum c3opt_alg)(val1);
  result = (struct c3Opt *)c3opt_create(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_c3Opt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_set_nvars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_set_nvars",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_set_nvars" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_set_nvars" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  c3opt_set_nvars(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  enum c3opt_alg arg1 ;
  size_t arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct c3Opt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_alloc",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3opt_alloc" "', argument " "1"" of type '" "enum c3opt_alg""'");
  } 
  arg1 = (enum c3opt_alg)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_alloc" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (struct c3Opt *)c3opt_alloc(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_c3Opt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct c3Opt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_copy" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (struct c3Opt *)c3opt_copy(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_c3Opt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_free" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  c3opt_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_set_sgd_learn_rate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_set_sgd_learn_rate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_set_sgd_learn_rate" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_set_sgd_learn_rate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  c3opt_set_sgd_learn_rate(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_set_sgd_nsamples(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_set_sgd_nsamples",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_set_sgd_nsamples" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_set_sgd_nsamples" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  c3opt_set_sgd_nsamples(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_get_sgd_nsamples(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_get_sgd_nsamples",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_get_sgd_nsamples" "', argument " "1"" of type '" "struct c3Opt const *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (size_t)c3opt_get_sgd_nsamples((struct c3Opt const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_set_nvectors_store(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_set_nvectors_store",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_set_nvectors_store" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_set_nvectors_store" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  c3opt_set_nvectors_store(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_get_nvectors_store(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_get_nvectors_store",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_get_nvectors_store" "', argument " "1"" of type '" "struct c3Opt const *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (size_t)c3opt_get_nvectors_store((struct c3Opt const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_set_lbfgs_scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_set_lbfgs_scale",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_set_lbfgs_scale" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_set_lbfgs_scale" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  c3opt_set_lbfgs_scale(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_get_lbfgs_scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_get_lbfgs_scale",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_get_lbfgs_scale" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (int)c3opt_get_lbfgs_scale(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_is_bruteforce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_is_bruteforce",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_is_bruteforce" "', argument " "1"" of type '" "struct c3Opt const *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (int)c3opt_is_bruteforce((struct c3Opt const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_is_sgd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_is_sgd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_is_sgd" "', argument " "1"" of type '" "struct c3Opt const *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (int)c3opt_is_sgd((struct c3Opt const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_add_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_add_lb",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_add_lb" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3opt_add_lb" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  c3opt_add_lb(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_add_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_add_ub",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_add_ub" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3opt_add_ub" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  c3opt_add_ub(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_add_objective(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double (*arg2)(size_t,double const *,double *,void *) = (double (*)(size_t,double const *,double *,void *)) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:c3opt_add_objective",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_add_objective" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_unsigned_long_p_q_const__double_p_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "c3opt_add_objective" "', argument " "2"" of type '" "double (*)(size_t,double const *,double *,void *)""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3opt_add_objective" "', argument " "3"" of type '" "void *""'"); 
  }
  c3opt_add_objective(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_add_objective_stoch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double (*arg2)(size_t,size_t,double const *,double *,void *) = (double (*)(size_t,size_t,double const *,double *,void *)) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:c3opt_add_objective_stoch",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_add_objective_stoch" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "c3opt_add_objective_stoch" "', argument " "2"" of type '" "double (*)(size_t,size_t,double const *,double *,void *)""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3opt_add_objective_stoch" "', argument " "3"" of type '" "void *""'"); 
  }
  c3opt_add_objective_stoch(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_set_verbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_set_verbose",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_set_verbose" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_set_verbose" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  c3opt_set_verbose(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_set_maxiter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_set_maxiter",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_set_maxiter" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_set_maxiter" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  c3opt_set_maxiter(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_get_maxiter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_get_maxiter",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_get_maxiter" "', argument " "1"" of type '" "struct c3Opt const *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (size_t)c3opt_get_maxiter((struct c3Opt const *)arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_set_absxtol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_set_absxtol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_set_absxtol" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_set_absxtol" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  c3opt_set_absxtol(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_get_niters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_get_niters",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_get_niters" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (size_t)c3opt_get_niters(arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_get_stored_function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_get_stored_function",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_get_stored_function" "', argument " "1"" of type '" "struct c3Opt const *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_get_stored_function" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double)c3opt_get_stored_function((struct c3Opt const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_get_nevals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_get_nevals",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_get_nevals" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (size_t)c3opt_get_nevals(arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_get_ngvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_get_ngvals",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_get_ngvals" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (size_t)c3opt_get_ngvals(arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_set_relftol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_set_relftol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_set_relftol" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_set_relftol" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  c3opt_set_relftol(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_set_gtol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_set_gtol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_set_gtol" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_set_gtol" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  c3opt_set_gtol(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_set_storage_options(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:c3opt_set_storage_options",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_set_storage_options" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_set_storage_options" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c3opt_set_storage_options" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "c3opt_set_storage_options" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  c3opt_set_storage_options(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_get_store_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_get_store_func",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_get_store_func" "', argument " "1"" of type '" "struct c3Opt const *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (int)c3opt_get_store_func((struct c3Opt const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_print_stored_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:c3opt_print_stored_values",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_print_stored_values" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3opt_print_stored_values" "', argument " "2"" of type '" "FILE *""'"); 
  }
  arg2 = (FILE *)(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c3opt_print_stored_values" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "c3opt_print_stored_values" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  c3opt_print_stored_values(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_ls_get_initial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_ls_get_initial",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_ls_get_initial" "', argument " "1"" of type '" "struct c3Opt const *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (int)c3opt_ls_get_initial((struct c3Opt const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_ls_set_alg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  enum c3opt_ls_alg arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_ls_set_alg",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_ls_set_alg" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_ls_set_alg" "', argument " "2"" of type '" "enum c3opt_ls_alg""'");
  } 
  arg2 = (enum c3opt_ls_alg)(val2);
  c3opt_ls_set_alg(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_ls_get_alg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum c3opt_ls_alg result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_ls_get_alg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_ls_get_alg" "', argument " "1"" of type '" "struct c3Opt const *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (enum c3opt_ls_alg)c3opt_ls_get_alg((struct c3Opt const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_ls_set_alpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_ls_set_alpha",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_ls_set_alpha" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_ls_set_alpha" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  c3opt_ls_set_alpha(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_ls_get_alpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_ls_get_alpha",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_ls_get_alpha" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (double)c3opt_ls_get_alpha(arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_ls_set_beta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_ls_set_beta",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_ls_set_beta" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_ls_set_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  c3opt_ls_set_beta(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_ls_get_beta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_ls_get_beta",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_ls_get_beta" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (double)c3opt_ls_get_beta(arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_ls_set_maxiter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_ls_set_maxiter",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_ls_set_maxiter" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_ls_set_maxiter" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  c3opt_ls_set_maxiter(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_ls_get_maxiter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_ls_get_maxiter",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_ls_get_maxiter" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (size_t)c3opt_ls_get_maxiter(arg1);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_ls_wolfe_bisect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double *arg2 = (double *) 0 ;
  double arg3 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  double *arg7 = (double *) 0 ;
  int *arg8 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:c3opt_ls_wolfe_bisect",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_ls_wolfe_bisect" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3opt_ls_wolfe_bisect" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c3opt_ls_wolfe_bisect" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "c3opt_ls_wolfe_bisect" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "c3opt_ls_wolfe_bisect" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "c3opt_ls_wolfe_bisect" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "c3opt_ls_wolfe_bisect" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "c3opt_ls_wolfe_bisect" "', argument " "8"" of type '" "int *""'"); 
  }
  arg8 = (int *)(argp8);
  result = (double)c3opt_ls_wolfe_bisect(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_ls_strong_wolfe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double *arg2 = (double *) 0 ;
  double arg3 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  double *arg7 = (double *) 0 ;
  int *arg8 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:c3opt_ls_strong_wolfe",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_ls_strong_wolfe" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3opt_ls_strong_wolfe" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c3opt_ls_strong_wolfe" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "c3opt_ls_strong_wolfe" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "c3opt_ls_strong_wolfe" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "c3opt_ls_strong_wolfe" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "c3opt_ls_strong_wolfe" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "c3opt_ls_strong_wolfe" "', argument " "8"" of type '" "int *""'"); 
  }
  arg8 = (int *)(argp8);
  result = (double)c3opt_ls_strong_wolfe(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_set_brute_force_vals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:c3opt_set_brute_force_vals",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_set_brute_force_vals" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_set_brute_force_vals" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3opt_set_brute_force_vals" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  c3opt_set_brute_force_vals(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_minimize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:c3opt_minimize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_minimize" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3opt_minimize" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3opt_minimize" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (int)c3opt_minimize(arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_get_lb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_get_lb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_get_lb" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (double *)c3opt_get_lb(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_get_ub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_get_ub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_get_ub" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  result = (double *)c3opt_get_ub(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:c3opt_eval",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_eval" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3opt_eval" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3opt_eval" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (double)c3opt_eval(arg1,(double const *)arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_eval_stoch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:c3opt_eval_stoch",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_eval_stoch" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_eval_stoch" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3opt_eval_stoch" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "c3opt_eval_stoch" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (double)c3opt_eval_stoch(arg1,arg2,(double const *)arg3,arg4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_check_deriv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double *arg2 = (double *) 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:c3opt_check_deriv",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_check_deriv" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3opt_check_deriv" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c3opt_check_deriv" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  result = (double)c3opt_check_deriv(arg1,(double const *)arg2,arg3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_check_deriv_each(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3Opt *arg1 = (struct c3Opt *) 0 ;
  double *arg2 = (double *) 0 ;
  double arg3 ;
  double *arg4 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:c3opt_check_deriv_each",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3Opt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_check_deriv_each" "', argument " "1"" of type '" "struct c3Opt *""'"); 
  }
  arg1 = (struct c3Opt *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3opt_check_deriv_each" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c3opt_check_deriv_each" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "c3opt_check_deriv_each" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  result = (double)c3opt_check_deriv_each(arg1,(double const *)arg2,arg3,arg4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_lbfgs_list_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct c3opt_lbfgs_list *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3opt_lbfgs_list_alloc",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c3opt_lbfgs_list_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_lbfgs_list_alloc" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (struct c3opt_lbfgs_list *)c3opt_lbfgs_list_alloc(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_c3opt_lbfgs_list, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_lbfgs_list_insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3opt_lbfgs_list *arg1 = (struct c3opt_lbfgs_list *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:c3opt_lbfgs_list_insert",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3opt_lbfgs_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_lbfgs_list_insert" "', argument " "1"" of type '" "struct c3opt_lbfgs_list *""'"); 
  }
  arg1 = (struct c3opt_lbfgs_list *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3opt_lbfgs_list_insert" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3opt_lbfgs_list_insert" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "c3opt_lbfgs_list_insert" "', argument " "4"" of type '" "double const *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "c3opt_lbfgs_list_insert" "', argument " "5"" of type '" "double const *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "c3opt_lbfgs_list_insert" "', argument " "6"" of type '" "double const *""'"); 
  }
  arg6 = (double *)(argp6);
  c3opt_lbfgs_list_insert(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_lbfgs_reset_step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3opt_lbfgs_list *arg1 = (struct c3opt_lbfgs_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_lbfgs_reset_step",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3opt_lbfgs_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_lbfgs_reset_step" "', argument " "1"" of type '" "struct c3opt_lbfgs_list *""'"); 
  }
  arg1 = (struct c3opt_lbfgs_list *)(argp1);
  c3opt_lbfgs_reset_step(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_lbfgs_list_step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3opt_lbfgs_list *arg1 = (struct c3opt_lbfgs_list *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  double **arg3 = (double **) 0 ;
  double **arg4 = (double **) 0 ;
  double *arg5 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:c3opt_lbfgs_list_step",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3opt_lbfgs_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_lbfgs_list_step" "', argument " "1"" of type '" "struct c3opt_lbfgs_list *""'"); 
  }
  arg1 = (struct c3opt_lbfgs_list *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3opt_lbfgs_list_step" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3opt_lbfgs_list_step" "', argument " "3"" of type '" "double **""'"); 
  }
  arg3 = (double **)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "c3opt_lbfgs_list_step" "', argument " "4"" of type '" "double **""'"); 
  }
  arg4 = (double **)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "c3opt_lbfgs_list_step" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  c3opt_lbfgs_list_step(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_lbfgs_list_step_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3opt_lbfgs_list *arg1 = (struct c3opt_lbfgs_list *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  double **arg3 = (double **) 0 ;
  double **arg4 = (double **) 0 ;
  double *arg5 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:c3opt_lbfgs_list_step_back",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3opt_lbfgs_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_lbfgs_list_step_back" "', argument " "1"" of type '" "struct c3opt_lbfgs_list *""'"); 
  }
  arg1 = (struct c3opt_lbfgs_list *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3opt_lbfgs_list_step_back" "', argument " "2"" of type '" "size_t *""'"); 
  }
  arg2 = (size_t *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3opt_lbfgs_list_step_back" "', argument " "3"" of type '" "double **""'"); 
  }
  arg3 = (double **)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "c3opt_lbfgs_list_step_back" "', argument " "4"" of type '" "double **""'"); 
  }
  arg4 = (double **)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "c3opt_lbfgs_list_step_back" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  c3opt_lbfgs_list_step_back(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_lbfgs_list_print(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3opt_lbfgs_list *arg1 = (struct c3opt_lbfgs_list *) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:c3opt_lbfgs_list_print",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3opt_lbfgs_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_lbfgs_list_print" "', argument " "1"" of type '" "struct c3opt_lbfgs_list *""'"); 
  }
  arg1 = (struct c3opt_lbfgs_list *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c3opt_lbfgs_list_print" "', argument " "2"" of type '" "FILE *""'"); 
  }
  arg2 = (FILE *)(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c3opt_lbfgs_list_print" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "c3opt_lbfgs_list_print" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  c3opt_lbfgs_list_print(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3opt_lbfgs_list_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct c3opt_lbfgs_list *arg1 = (struct c3opt_lbfgs_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3opt_lbfgs_list_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_c3opt_lbfgs_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3opt_lbfgs_list_free" "', argument " "1"" of type '" "struct c3opt_lbfgs_list *""'"); 
  }
  arg1 = (struct c3opt_lbfgs_list *)(argp1);
  c3opt_lbfgs_list_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_newton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double **arg1 = (double **) 0 ;
  size_t arg2 ;
  double arg3 ;
  double arg4 ;
  double *(*arg5)(double *,void *) = (double *(*)(double *,void *)) 0 ;
  double *(*arg6)(double *,void *) = (double *(*)(double *,void *)) 0 ;
  void *arg7 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int res7 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:newton",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "newton" "', argument " "1"" of type '" "double **""'"); 
  }
  arg1 = (double **)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "newton" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "newton" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "newton" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  {
    int res = SWIG_ConvertFunctionPtr(obj4, (void**)(&arg5), SWIGTYPE_p_f_p_double_p_void__p_double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "newton" "', argument " "5"" of type '" "double *(*)(double *,void *)""'"); 
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(obj5, (void**)(&arg6), SWIGTYPE_p_f_p_double_p_void__p_double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "newton" "', argument " "6"" of type '" "double *(*)(double *,void *)""'"); 
    }
  }
  res7 = SWIG_ConvertPtr(obj6,SWIG_as_voidptrptr(&arg7), 0, 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "newton" "', argument " "7"" of type '" "void *""'"); 
  }
  newton(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_backtrack_line_search(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double arg3 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  double *arg7 = (double *) 0 ;
  double arg8 ;
  double arg9 ;
  double (*arg10)(double *,void *) = (double (*)(double *,void *)) 0 ;
  void *arg11 = (void *) 0 ;
  size_t arg12 ;
  int *arg13 = (int *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int res11 ;
  size_t val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:backtrack_line_search",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "backtrack_line_search" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "backtrack_line_search" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "backtrack_line_search" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "backtrack_line_search" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "backtrack_line_search" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "backtrack_line_search" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "backtrack_line_search" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "backtrack_line_search" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = (double)(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "backtrack_line_search" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = (double)(val9);
  {
    int res = SWIG_ConvertFunctionPtr(obj9, (void**)(&arg10), SWIGTYPE_p_f_p_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "backtrack_line_search" "', argument " "10"" of type '" "double (*)(double *,void *)""'"); 
    }
  }
  res11 = SWIG_ConvertPtr(obj10,SWIG_as_voidptrptr(&arg11), 0, 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "backtrack_line_search" "', argument " "11"" of type '" "void *""'"); 
  }
  ecode12 = SWIG_AsVal_size_t(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "backtrack_line_search" "', argument " "12"" of type '" "size_t""'");
  } 
  arg12 = (size_t)(val12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "backtrack_line_search" "', argument " "13"" of type '" "int *""'"); 
  }
  arg13 = (int *)(argp13);
  result = (double)backtrack_line_search(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_backtrack_line_search_bc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double arg5 ;
  double *arg6 = (double *) 0 ;
  double *arg7 = (double *) 0 ;
  double *arg8 = (double *) 0 ;
  double *arg9 = (double *) 0 ;
  double arg10 ;
  double arg11 ;
  double (*arg12)(double *,void *) = (double (*)(double *,void *)) 0 ;
  void *arg13 = (void *) 0 ;
  size_t arg14 ;
  int *arg15 = (int *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int res13 ;
  size_t val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:backtrack_line_search_bc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "backtrack_line_search_bc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "backtrack_line_search_bc" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "backtrack_line_search_bc" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "backtrack_line_search_bc" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "backtrack_line_search_bc" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "backtrack_line_search_bc" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "backtrack_line_search_bc" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "backtrack_line_search_bc" "', argument " "8"" of type '" "double *""'"); 
  }
  arg8 = (double *)(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "backtrack_line_search_bc" "', argument " "9"" of type '" "double *""'"); 
  }
  arg9 = (double *)(argp9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "backtrack_line_search_bc" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = (double)(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "backtrack_line_search_bc" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = (double)(val11);
  {
    int res = SWIG_ConvertFunctionPtr(obj11, (void**)(&arg12), SWIGTYPE_p_f_p_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "backtrack_line_search_bc" "', argument " "12"" of type '" "double (*)(double *,void *)""'"); 
    }
  }
  res13 = SWIG_ConvertPtr(obj12,SWIG_as_voidptrptr(&arg13), 0, 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "backtrack_line_search_bc" "', argument " "13"" of type '" "void *""'"); 
  }
  ecode14 = SWIG_AsVal_size_t(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "backtrack_line_search_bc" "', argument " "14"" of type '" "size_t""'");
  } 
  arg14 = (size_t)(val14);
  res15 = SWIG_ConvertPtr(obj14, &argp15,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "backtrack_line_search_bc" "', argument " "15"" of type '" "int *""'"); 
  }
  arg15 = (int *)(argp15);
  result = (double)backtrack_line_search_bc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gradient_descent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double (*arg6)(double *,void *) = (double (*)(double *,void *)) 0 ;
  void *arg7 = (void *) 0 ;
  int (*arg8)(double *,double *,void *) = (int (*)(double *,double *,void *)) 0 ;
  void *arg9 = (void *) 0 ;
  double arg10 ;
  size_t arg11 ;
  size_t arg12 ;
  double arg13 ;
  double arg14 ;
  int arg15 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res7 ;
  int res9 ;
  double val10 ;
  int ecode10 = 0 ;
  size_t val11 ;
  int ecode11 = 0 ;
  size_t val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:gradient_descent",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gradient_descent" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gradient_descent" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gradient_descent" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gradient_descent" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gradient_descent" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  {
    int res = SWIG_ConvertFunctionPtr(obj5, (void**)(&arg6), SWIGTYPE_p_f_p_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gradient_descent" "', argument " "6"" of type '" "double (*)(double *,void *)""'"); 
    }
  }
  res7 = SWIG_ConvertPtr(obj6,SWIG_as_voidptrptr(&arg7), 0, 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "gradient_descent" "', argument " "7"" of type '" "void *""'"); 
  }
  {
    int res = SWIG_ConvertFunctionPtr(obj7, (void**)(&arg8), SWIGTYPE_p_f_p_double_p_double_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gradient_descent" "', argument " "8"" of type '" "int (*)(double *,double *,void *)""'"); 
    }
  }
  res9 = SWIG_ConvertPtr(obj8,SWIG_as_voidptrptr(&arg9), 0, 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "gradient_descent" "', argument " "9"" of type '" "void *""'"); 
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "gradient_descent" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = (double)(val10);
  ecode11 = SWIG_AsVal_size_t(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "gradient_descent" "', argument " "11"" of type '" "size_t""'");
  } 
  arg11 = (size_t)(val11);
  ecode12 = SWIG_AsVal_size_t(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "gradient_descent" "', argument " "12"" of type '" "size_t""'");
  } 
  arg12 = (size_t)(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "gradient_descent" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = (double)(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "gradient_descent" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = (double)(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "gradient_descent" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = (int)(val15);
  result = (int)gradient_descent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_box_pg_descent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  double *arg7 = (double *) 0 ;
  double (*arg8)(double *,void *) = (double (*)(double *,void *)) 0 ;
  void *arg9 = (void *) 0 ;
  int (*arg10)(double *,double *,void *) = (int (*)(double *,double *,void *)) 0 ;
  void *arg11 = (void *) 0 ;
  double arg12 ;
  size_t arg13 ;
  size_t arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int res9 ;
  int res11 ;
  double val12 ;
  int ecode12 = 0 ;
  size_t val13 ;
  int ecode13 = 0 ;
  size_t val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:box_pg_descent",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "box_pg_descent" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "box_pg_descent" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "box_pg_descent" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "box_pg_descent" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "box_pg_descent" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "box_pg_descent" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "box_pg_descent" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  {
    int res = SWIG_ConvertFunctionPtr(obj7, (void**)(&arg8), SWIGTYPE_p_f_p_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "box_pg_descent" "', argument " "8"" of type '" "double (*)(double *,void *)""'"); 
    }
  }
  res9 = SWIG_ConvertPtr(obj8,SWIG_as_voidptrptr(&arg9), 0, 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "box_pg_descent" "', argument " "9"" of type '" "void *""'"); 
  }
  {
    int res = SWIG_ConvertFunctionPtr(obj9, (void**)(&arg10), SWIGTYPE_p_f_p_double_p_double_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "box_pg_descent" "', argument " "10"" of type '" "int (*)(double *,double *,void *)""'"); 
    }
  }
  res11 = SWIG_ConvertPtr(obj10,SWIG_as_voidptrptr(&arg11), 0, 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "box_pg_descent" "', argument " "11"" of type '" "void *""'"); 
  }
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "box_pg_descent" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = (double)(val12);
  ecode13 = SWIG_AsVal_size_t(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "box_pg_descent" "', argument " "13"" of type '" "size_t""'");
  } 
  arg13 = (size_t)(val13);
  ecode14 = SWIG_AsVal_size_t(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "box_pg_descent" "', argument " "14"" of type '" "size_t""'");
  } 
  arg14 = (size_t)(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "box_pg_descent" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = (double)(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "box_pg_descent" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = (double)(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "box_pg_descent" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = (int)(val17);
  result = (int)box_pg_descent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_box_damp_newton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  double *arg7 = (double *) 0 ;
  double *arg8 = (double *) 0 ;
  double (*arg9)(double *,void *) = (double (*)(double *,void *)) 0 ;
  void *arg10 = (void *) 0 ;
  int (*arg11)(double *,double *,void *) = (int (*)(double *,double *,void *)) 0 ;
  void *arg12 = (void *) 0 ;
  int (*arg13)(double *,double *,void *) = (int (*)(double *,double *,void *)) 0 ;
  void *arg14 = (void *) 0 ;
  double arg15 ;
  size_t arg16 ;
  size_t arg17 ;
  double arg18 ;
  double arg19 ;
  int arg20 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int res10 ;
  int res12 ;
  int res14 ;
  double val15 ;
  int ecode15 = 0 ;
  size_t val16 ;
  int ecode16 = 0 ;
  size_t val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  int val20 ;
  int ecode20 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:box_damp_newton",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "box_damp_newton" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "box_damp_newton" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "box_damp_newton" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "box_damp_newton" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "box_damp_newton" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "box_damp_newton" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "box_damp_newton" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "box_damp_newton" "', argument " "8"" of type '" "double *""'"); 
  }
  arg8 = (double *)(argp8);
  {
    int res = SWIG_ConvertFunctionPtr(obj8, (void**)(&arg9), SWIGTYPE_p_f_p_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "box_damp_newton" "', argument " "9"" of type '" "double (*)(double *,void *)""'"); 
    }
  }
  res10 = SWIG_ConvertPtr(obj9,SWIG_as_voidptrptr(&arg10), 0, 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "box_damp_newton" "', argument " "10"" of type '" "void *""'"); 
  }
  {
    int res = SWIG_ConvertFunctionPtr(obj10, (void**)(&arg11), SWIGTYPE_p_f_p_double_p_double_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "box_damp_newton" "', argument " "11"" of type '" "int (*)(double *,double *,void *)""'"); 
    }
  }
  res12 = SWIG_ConvertPtr(obj11,SWIG_as_voidptrptr(&arg12), 0, 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "box_damp_newton" "', argument " "12"" of type '" "void *""'"); 
  }
  {
    int res = SWIG_ConvertFunctionPtr(obj12, (void**)(&arg13), SWIGTYPE_p_f_p_double_p_double_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "box_damp_newton" "', argument " "13"" of type '" "int (*)(double *,double *,void *)""'"); 
    }
  }
  res14 = SWIG_ConvertPtr(obj13,SWIG_as_voidptrptr(&arg14), 0, 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "box_damp_newton" "', argument " "14"" of type '" "void *""'"); 
  }
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "box_damp_newton" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = (double)(val15);
  ecode16 = SWIG_AsVal_size_t(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "box_damp_newton" "', argument " "16"" of type '" "size_t""'");
  } 
  arg16 = (size_t)(val16);
  ecode17 = SWIG_AsVal_size_t(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "box_damp_newton" "', argument " "17"" of type '" "size_t""'");
  } 
  arg17 = (size_t)(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "box_damp_newton" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = (double)(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "box_damp_newton" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = (double)(val19);
  ecode20 = SWIG_AsVal_int(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "box_damp_newton" "', argument " "20"" of type '" "int""'");
  } 
  arg20 = (int)(val20);
  result = (int)box_damp_newton(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_box_damp_bfgs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  double *arg6 = (double *) 0 ;
  double *arg7 = (double *) 0 ;
  double *arg8 = (double *) 0 ;
  double (*arg9)(double *,void *) = (double (*)(double *,void *)) 0 ;
  void *arg10 = (void *) 0 ;
  int (*arg11)(double *,double *,void *) = (int (*)(double *,double *,void *)) 0 ;
  double arg12 ;
  size_t arg13 ;
  size_t arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int res10 ;
  double val12 ;
  int ecode12 = 0 ;
  size_t val13 ;
  int ecode13 = 0 ;
  size_t val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:box_damp_bfgs",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "box_damp_bfgs" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "box_damp_bfgs" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "box_damp_bfgs" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "box_damp_bfgs" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "box_damp_bfgs" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "box_damp_bfgs" "', argument " "6"" of type '" "double *""'"); 
  }
  arg6 = (double *)(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "box_damp_bfgs" "', argument " "7"" of type '" "double *""'"); 
  }
  arg7 = (double *)(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "box_damp_bfgs" "', argument " "8"" of type '" "double *""'"); 
  }
  arg8 = (double *)(argp8);
  {
    int res = SWIG_ConvertFunctionPtr(obj8, (void**)(&arg9), SWIGTYPE_p_f_p_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "box_damp_bfgs" "', argument " "9"" of type '" "double (*)(double *,void *)""'"); 
    }
  }
  res10 = SWIG_ConvertPtr(obj9,SWIG_as_voidptrptr(&arg10), 0, 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "box_damp_bfgs" "', argument " "10"" of type '" "void *""'"); 
  }
  {
    int res = SWIG_ConvertFunctionPtr(obj10, (void**)(&arg11), SWIGTYPE_p_f_p_double_p_double_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "box_damp_bfgs" "', argument " "11"" of type '" "int (*)(double *,double *,void *)""'"); 
    }
  }
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "box_damp_bfgs" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = (double)(val12);
  ecode13 = SWIG_AsVal_size_t(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "box_damp_bfgs" "', argument " "13"" of type '" "size_t""'");
  } 
  arg13 = (size_t)(val13);
  ecode14 = SWIG_AsVal_size_t(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "box_damp_bfgs" "', argument " "14"" of type '" "size_t""'");
  } 
  arg14 = (size_t)(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "box_damp_bfgs" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = (double)(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "box_damp_bfgs" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = (double)(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "box_damp_bfgs" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = (int)(val17);
  result = (int)box_damp_bfgs(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3_sobol_sensitivity_calculate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct FunctionTrain *arg1 = (struct FunctionTrain *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  struct C3SobolSensitivity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3_sobol_sensitivity_calculate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FunctionTrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3_sobol_sensitivity_calculate" "', argument " "1"" of type '" "struct FunctionTrain const *""'"); 
  }
  arg1 = (struct FunctionTrain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3_sobol_sensitivity_calculate" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (struct C3SobolSensitivity *)c3_sobol_sensitivity_calculate((struct FunctionTrain const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_C3SobolSensitivity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3_sobol_sensitivity_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3SobolSensitivity *arg1 = (struct C3SobolSensitivity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3_sobol_sensitivity_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3SobolSensitivity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3_sobol_sensitivity_free" "', argument " "1"" of type '" "struct C3SobolSensitivity *""'"); 
  }
  arg1 = (struct C3SobolSensitivity *)(argp1);
  c3_sobol_sensitivity_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3_sobol_sensitivity_get_interaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3SobolSensitivity *arg1 = (struct C3SobolSensitivity *) 0 ;
  size_t arg2 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyArrayObject *array2 = NULL ;
  int is_new_object2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3_sobol_sensitivity_get_interaction",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3SobolSensitivity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3_sobol_sensitivity_get_interaction" "', argument " "1"" of type '" "struct C3SobolSensitivity const *""'"); 
  }
  arg1 = (struct C3SobolSensitivity *)(argp1);
  {
    npy_intp size[1] = {
      -1
    };
    array2 = obj_to_array_contiguous_allow_conversion(obj1,
      NPY_ULONG,
      &is_new_object2);
    if (!array2 || !require_dimensions(array2, 1) ||
      !require_size(array2, size, 1)) SWIG_fail;
    arg2 = (int) array_size(array2,0);
    arg3 = (unsigned long*) array_data(array2);
  }
  result = (double)c3_sobol_sensitivity_get_interaction((struct C3SobolSensitivity const *)arg1,arg2,(unsigned long const *)arg3);
  resultobj = SWIG_From_double((double)(result));
  {
    if (is_new_object2 && array2)
    {
      Py_DECREF(array2); 
    }
  }
  return resultobj;
fail:
  {
    if (is_new_object2 && array2)
    {
      Py_DECREF(array2); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3_sobol_sensitivity_get_total(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3SobolSensitivity *arg1 = (struct C3SobolSensitivity *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3_sobol_sensitivity_get_total",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3SobolSensitivity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3_sobol_sensitivity_get_total" "', argument " "1"" of type '" "struct C3SobolSensitivity const *""'"); 
  }
  arg1 = (struct C3SobolSensitivity *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3_sobol_sensitivity_get_total" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double)c3_sobol_sensitivity_get_total((struct C3SobolSensitivity const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3_sobol_sensitivity_get_main(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3SobolSensitivity *arg1 = (struct C3SobolSensitivity *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:c3_sobol_sensitivity_get_main",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3SobolSensitivity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3_sobol_sensitivity_get_main" "', argument " "1"" of type '" "struct C3SobolSensitivity const *""'"); 
  }
  arg1 = (struct C3SobolSensitivity *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c3_sobol_sensitivity_get_main" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = (double)c3_sobol_sensitivity_get_main((struct C3SobolSensitivity const *)arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3_sobol_sensitivity_get_variance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3SobolSensitivity *arg1 = (struct C3SobolSensitivity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3_sobol_sensitivity_get_variance",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3SobolSensitivity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3_sobol_sensitivity_get_variance" "', argument " "1"" of type '" "struct C3SobolSensitivity const *""'"); 
  }
  arg1 = (struct C3SobolSensitivity *)(argp1);
  result = (double)c3_sobol_sensitivity_get_variance((struct C3SobolSensitivity const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3_sobol_sensitivity_print(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3SobolSensitivity *arg1 = (struct C3SobolSensitivity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:c3_sobol_sensitivity_print",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3SobolSensitivity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3_sobol_sensitivity_print" "', argument " "1"" of type '" "struct C3SobolSensitivity const *""'"); 
  }
  arg1 = (struct C3SobolSensitivity *)(argp1);
  c3_sobol_sensitivity_print((struct C3SobolSensitivity const *)arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_c3_sobol_sensitivity_apply_external(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct C3SobolSensitivity *arg1 = (struct C3SobolSensitivity *) 0 ;
  void (*arg2)(double,size_t,size_t *,void *) = (void (*)(double,size_t,size_t *,void *)) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:c3_sobol_sensitivity_apply_external",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_C3SobolSensitivity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c3_sobol_sensitivity_apply_external" "', argument " "1"" of type '" "struct C3SobolSensitivity const *""'"); 
  }
  arg1 = (struct C3SobolSensitivity *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_double_unsigned_long_p_unsigned_long_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "c3_sobol_sensitivity_apply_external" "', argument " "2"" of type '" "void (*)(double,size_t,size_t *,void *)""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "c3_sobol_sensitivity_apply_external" "', argument " "3"" of type '" "void *""'"); 
  }
  c3_sobol_sensitivity_apply_external((struct C3SobolSensitivity const *)arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_A_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinearTransform_A_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_A_set" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearTransform_A_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->A = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_A_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinearTransform_A_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_A_get" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  result = (double *) ((arg1)->A);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_b_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinearTransform_b_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_b_set" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearTransform_b_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->b = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_b_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinearTransform_b_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_b_get" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  result = (double *) ((arg1)->b);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_det_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinearTransform_det_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_det_set" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearTransform_det_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->det = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_det_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinearTransform_det_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_det_get" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  result = (double) ((arg1)->det);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_Ainv_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinearTransform_Ainv_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_Ainv_set" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearTransform_Ainv_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->Ainv = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_Ainv_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinearTransform_Ainv_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_Ainv_get" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  result = (double *) ((arg1)->Ainv);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_binv_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinearTransform_binv_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_binv_set" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearTransform_binv_set" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  if (arg1) (arg1)->binv = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_binv_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinearTransform_binv_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_binv_get" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  result = (double *) ((arg1)->binv);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_detinv_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinearTransform_detinv_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_detinv_set" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearTransform_detinv_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->detinv = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_detinv_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinearTransform_detinv_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_detinv_get" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  result = (double) ((arg1)->detinv);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_dimin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinearTransform_dimin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_dimin_set" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearTransform_dimin_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->dimin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_dimin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinearTransform_dimin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_dimin_get" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  result = (size_t) ((arg1)->dimin);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_dimout_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinearTransform_dimout_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_dimout_set" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearTransform_dimout_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->dimout = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_dimout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinearTransform_dimout_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_dimout_get" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  result = (size_t) ((arg1)->dimout);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_mt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  enum lt_matrix_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinearTransform_mt_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_mt_set" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearTransform_mt_set" "', argument " "2"" of type '" "enum lt_matrix_type""'");
  } 
  arg2 = (enum lt_matrix_type)(val2);
  if (arg1) (arg1)->mt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_mt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum lt_matrix_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinearTransform_mt_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_mt_get" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  result = (enum lt_matrix_type) ((arg1)->mt);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_mti_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  enum lt_matrix_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LinearTransform_mti_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_mti_set" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearTransform_mti_set" "', argument " "2"" of type '" "enum lt_matrix_type""'");
  } 
  arg2 = (enum lt_matrix_type)(val2);
  if (arg1) (arg1)->mti = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTransform_mti_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum lt_matrix_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LinearTransform_mti_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTransform_mti_get" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  result = (enum lt_matrix_type) ((arg1)->mti);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LinearTransform")) SWIG_fail;
  result = (struct LinearTransform *)calloc(1, sizeof(struct LinearTransform));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTransform, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LinearTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LinearTransform",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinearTransform" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_ProbabilityDensity_pdf_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProbabilityDensity_pdf_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProbabilityDensity_pdf_set" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProbabilityDensity_pdf_set" "', argument " "2"" of type '" "struct FunctionTrain *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  if (arg1) (arg1)->pdf = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProbabilityDensity_pdf_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProbabilityDensity_pdf_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProbabilityDensity_pdf_get" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  result = (struct FunctionTrain *) ((arg1)->pdf);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProbabilityDensity_lt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  struct LinearTransform *arg2 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProbabilityDensity_lt_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProbabilityDensity_lt_set" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_LinearTransform, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProbabilityDensity_lt_set" "', argument " "2"" of type '" "struct LinearTransform *""'"); 
  }
  arg2 = (struct LinearTransform *)(argp2);
  if (arg1) (arg1)->lt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProbabilityDensity_lt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct LinearTransform *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProbabilityDensity_lt_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProbabilityDensity_lt_get" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  result = (struct LinearTransform *) ((arg1)->lt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTransform, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProbabilityDensity_transform_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProbabilityDensity_transform_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProbabilityDensity_transform_set" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProbabilityDensity_transform_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->transform = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProbabilityDensity_transform_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProbabilityDensity_transform_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProbabilityDensity_transform_get" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  result = (int) ((arg1)->transform);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProbabilityDensity_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  enum pdf_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProbabilityDensity_type_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProbabilityDensity_type_set" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProbabilityDensity_type_set" "', argument " "2"" of type '" "enum pdf_type""'");
  } 
  arg2 = (enum pdf_type)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProbabilityDensity_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum pdf_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProbabilityDensity_type_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProbabilityDensity_type_get" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  result = (enum pdf_type) ((arg1)->type);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProbabilityDensity_extra_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProbabilityDensity_extra_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProbabilityDensity_extra_set" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProbabilityDensity_extra_set" "', argument " "2"" of type '" "void *""'"); 
  }
  if (arg1) (arg1)->extra = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProbabilityDensity_extra_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProbabilityDensity_extra_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProbabilityDensity_extra_get" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  result = (void *) ((arg1)->extra);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProbabilityDensity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ProbabilityDensity")) SWIG_fail;
  result = (struct ProbabilityDensity *)calloc(1, sizeof(struct ProbabilityDensity));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ProbabilityDensity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ProbabilityDensity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ProbabilityDensity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ProbabilityDensity" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_linear_transform_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double arg5 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  struct LinearTransform *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:linear_transform_alloc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "linear_transform_alloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "linear_transform_alloc" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "linear_transform_alloc" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "linear_transform_alloc" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "linear_transform_alloc" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  result = (struct LinearTransform *)linear_transform_alloc(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTransform, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_linear_transform_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct LinearTransform *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:linear_transform_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "linear_transform_copy" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  result = (struct LinearTransform *)linear_transform_copy(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTransform, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_linear_transform_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:linear_transform_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "linear_transform_free" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  linear_transform_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_linear_transform_apply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  double *arg5 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:linear_transform_apply",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "linear_transform_apply" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "linear_transform_apply" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "linear_transform_apply" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "linear_transform_apply" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "linear_transform_apply" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  result = (double *)linear_transform_apply(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_linear_transform_invert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct LinearTransform *arg1 = (struct LinearTransform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:linear_transform_invert",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "linear_transform_invert" "', argument " "1"" of type '" "struct LinearTransform *""'"); 
  }
  arg1 = (struct LinearTransform *)(argp1);
  linear_transform_invert(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_linear_transform_serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct LinearTransform *arg2 = (struct LinearTransform *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:linear_transform_serialize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "linear_transform_serialize" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "linear_transform_serialize" "', argument " "2"" of type '" "struct LinearTransform *""'"); 
  }
  arg2 = (struct LinearTransform *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "linear_transform_serialize" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (unsigned char *)linear_transform_serialize(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_linear_transform_deserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct LinearTransform **arg2 = (struct LinearTransform **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:linear_transform_deserialize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "linear_transform_deserialize" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_LinearTransform, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "linear_transform_deserialize" "', argument " "2"" of type '" "struct LinearTransform **""'"); 
  }
  arg2 = (struct LinearTransform **)(argp2);
  result = (unsigned char *)linear_transform_deserialize(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_alloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":probability_density_alloc")) SWIG_fail;
  result = (struct ProbabilityDensity *)probability_density_alloc();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:probability_density_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probability_density_free" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  probability_density_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct ProbabilityDensity *arg2 = (struct ProbabilityDensity *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:probability_density_serialize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probability_density_serialize" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "probability_density_serialize" "', argument " "2"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg2 = (struct ProbabilityDensity *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "probability_density_serialize" "', argument " "3"" of type '" "size_t *""'"); 
  }
  arg3 = (size_t *)(argp3);
  result = (unsigned char *)probability_density_serialize(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_deserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  struct ProbabilityDensity **arg2 = (struct ProbabilityDensity **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:probability_density_deserialize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probability_density_deserialize" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "probability_density_deserialize" "', argument " "2"" of type '" "struct ProbabilityDensity **""'"); 
  }
  arg2 = (struct ProbabilityDensity **)(argp2);
  result = (unsigned char *)probability_density_deserialize(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:probability_density_save",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probability_density_save" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "probability_density_save" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  result = (int)probability_density_save(arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  struct ProbabilityDensity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:probability_density_load",&obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probability_density_load" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  result = (struct ProbabilityDensity *)probability_density_load(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:probability_density_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probability_density_eval" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "probability_density_eval" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (double)probability_density_eval(arg1,arg2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_log_gradient_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:probability_density_log_gradient_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probability_density_log_gradient_eval" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "probability_density_log_gradient_eval" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (double *)probability_density_log_gradient_eval(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_log_hessian_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:probability_density_log_hessian_eval",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probability_density_log_hessian_eval" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "probability_density_log_hessian_eval" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  result = (double *)probability_density_log_hessian_eval(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_lb_base(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:probability_density_lb_base",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probability_density_lb_base" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  result = (double *)probability_density_lb_base(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_ub_base(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:probability_density_ub_base",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probability_density_ub_base" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  result = (double *)probability_density_ub_base(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_standard_normal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  struct ProbabilityDensity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:probability_density_standard_normal",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "probability_density_standard_normal" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (struct ProbabilityDensity *)probability_density_standard_normal(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_mvn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  struct ProbabilityDensity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:probability_density_mvn",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "probability_density_mvn" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "probability_density_mvn" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "probability_density_mvn" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (struct ProbabilityDensity *)probability_density_mvn(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_sample(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct ProbabilityDensity *arg1 = (struct ProbabilityDensity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:probability_density_sample",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probability_density_sample" "', argument " "1"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg1 = (struct ProbabilityDensity *)(argp1);
  result = (double *)probability_density_sample(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probability_density_laplace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double (*arg1)(size_t,double const *,double *,void *) = (double (*)(size_t,double const *,double *,void *)) 0 ;
  double *(*arg2)(double *,void *) = (double *(*)(double *,void *)) 0 ;
  void *arg3 = (void *) 0 ;
  size_t arg4 ;
  double *arg5 = (double *) 0 ;
  int res3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  struct ProbabilityDensity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:probability_density_laplace",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_unsigned_long_p_q_const__double_p_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "probability_density_laplace" "', argument " "1"" of type '" "double (*)(size_t,double const *,double *,void *)""'"); 
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_double_p_void__p_double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "probability_density_laplace" "', argument " "2"" of type '" "double *(*)(double *,void *)""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "probability_density_laplace" "', argument " "3"" of type '" "void *""'"); 
  }
  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "probability_density_laplace" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "probability_density_laplace" "', argument " "5"" of type '" "double *""'"); 
  }
  arg5 = (double *)(argp5);
  result = (struct ProbabilityDensity *)probability_density_laplace(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Likelihood_datadim_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Likelihood_datadim_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Likelihood_datadim_set" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Likelihood_datadim_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->datadim = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Likelihood_datadim_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Likelihood_datadim_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Likelihood_datadim_get" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  result = (size_t) ((arg1)->datadim);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Likelihood_paramdim_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Likelihood_paramdim_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Likelihood_paramdim_set" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Likelihood_paramdim_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->paramdim = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Likelihood_paramdim_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Likelihood_paramdim_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Likelihood_paramdim_get" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  result = (size_t) ((arg1)->paramdim);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Likelihood_inputdim_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Likelihood_inputdim_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Likelihood_inputdim_set" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Likelihood_inputdim_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->inputdim = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Likelihood_inputdim_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Likelihood_inputdim_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Likelihood_inputdim_get" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  result = (size_t) ((arg1)->inputdim);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Likelihood_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  enum likelihood_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Likelihood_type_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Likelihood_type_set" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Likelihood_type_set" "', argument " "2"" of type '" "enum likelihood_type""'");
  } 
  arg2 = (enum likelihood_type)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Likelihood_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  enum likelihood_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Likelihood_type_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Likelihood_type_get" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  result = (enum likelihood_type) ((arg1)->type);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Likelihood_like_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  struct FunctionTrain *arg2 = (struct FunctionTrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Likelihood_like_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Likelihood_like_set" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FunctionTrain, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Likelihood_like_set" "', argument " "2"" of type '" "struct FunctionTrain *""'"); 
  }
  arg2 = (struct FunctionTrain *)(argp2);
  if (arg1) (arg1)->like = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Likelihood_like_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct FunctionTrain *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Likelihood_like_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Likelihood_like_get" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  result = (struct FunctionTrain *) ((arg1)->like);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionTrain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Likelihood_loglike_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Likelihood_loglike_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Likelihood_loglike_set" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Likelihood_loglike_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->loglike = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Likelihood_loglike_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Likelihood_loglike_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Likelihood_loglike_get" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  result = (int) ((arg1)->loglike);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Likelihood_logextra_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Likelihood_logextra_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Likelihood_logextra_set" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Likelihood_logextra_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->logextra = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Likelihood_logextra_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Likelihood_logextra_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Likelihood_logextra_get" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  result = (double) ((arg1)->logextra);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Likelihood(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Likelihood")) SWIG_fail;
  result = (struct Likelihood *)calloc(1, sizeof(struct Likelihood));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Likelihood, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Likelihood(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Likelihood",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Likelihood" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_likelihood_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct Likelihood *arg1 = (struct Likelihood *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:likelihood_free",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Likelihood, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "likelihood_free" "', argument " "1"" of type '" "struct Likelihood *""'"); 
  }
  arg1 = (struct Likelihood *)(argp1);
  likelihood_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesRule_like_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct BayesRule *arg1 = (struct BayesRule *) 0 ;
  struct Likelihood *arg2 = (struct Likelihood *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BayesRule_like_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BayesRule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesRule_like_set" "', argument " "1"" of type '" "struct BayesRule *""'"); 
  }
  arg1 = (struct BayesRule *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Likelihood, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesRule_like_set" "', argument " "2"" of type '" "struct Likelihood *""'"); 
  }
  arg2 = (struct Likelihood *)(argp2);
  if (arg1) (arg1)->like = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesRule_like_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct BayesRule *arg1 = (struct BayesRule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct Likelihood *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BayesRule_like_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BayesRule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesRule_like_get" "', argument " "1"" of type '" "struct BayesRule *""'"); 
  }
  arg1 = (struct BayesRule *)(argp1);
  result = (struct Likelihood *) ((arg1)->like);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Likelihood, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesRule_prior_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct BayesRule *arg1 = (struct BayesRule *) 0 ;
  struct ProbabilityDensity *arg2 = (struct ProbabilityDensity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BayesRule_prior_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BayesRule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesRule_prior_set" "', argument " "1"" of type '" "struct BayesRule *""'"); 
  }
  arg1 = (struct BayesRule *)(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ProbabilityDensity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesRule_prior_set" "', argument " "2"" of type '" "struct ProbabilityDensity *""'"); 
  }
  arg2 = (struct ProbabilityDensity *)(argp2);
  if (arg1) (arg1)->prior = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesRule_prior_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct BayesRule *arg1 = (struct BayesRule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  struct ProbabilityDensity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BayesRule_prior_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BayesRule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesRule_prior_get" "', argument " "1"" of type '" "struct BayesRule *""'"); 
  }
  arg1 = (struct BayesRule *)(argp1);
  result = (struct ProbabilityDensity *) ((arg1)->prior);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ProbabilityDensity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BayesRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct BayesRule *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BayesRule")) SWIG_fail;
  result = (struct BayesRule *)calloc(1, sizeof(struct BayesRule));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BayesRule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BayesRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct BayesRule *arg1 = (struct BayesRule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BayesRule",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BayesRule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BayesRule" "', argument " "1"" of type '" "struct BayesRule *""'"); 
  }
  arg1 = (struct BayesRule *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_trap_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:trap_w",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "trap_w" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "trap_w" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double *)trap_w(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simpson_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:simpson_w",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "simpson_w" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simpson_w" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  result = (double *)simpson_w(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_clenshaw_curtis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:clenshaw_curtis",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "clenshaw_curtis" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "clenshaw_curtis" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "clenshaw_curtis" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  clenshaw_curtis(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rescale_cc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  double arg4 ;
  double arg5 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:rescale_cc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "rescale_cc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rescale_cc" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rescale_cc" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "rescale_cc" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "rescale_cc" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  rescale_cc(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fejer2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:fejer2",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fejer2" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fejer2" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fejer2" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  fejer2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cheb_gauss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:cheb_gauss",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cheb_gauss" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cheb_gauss" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cheb_gauss" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (int)cheb_gauss(arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gauss_hermite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:gauss_hermite",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gauss_hermite" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gauss_hermite" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gauss_hermite" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  result = (int)gauss_hermite(arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gauss_legendre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:gauss_legendre",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gauss_legendre" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gauss_legendre" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gauss_legendre" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  gauss_legendre(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


static PyMethodDef SwigMethods[] = {
	 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { (char *)"c3py_wrapped_eval", _wrap_c3py_wrapped_eval, METH_VARARGS, NULL},
	 { (char *)"fwrap_set_pyfunc", _wrap_fwrap_set_pyfunc, METH_VARARGS, NULL},
	 { (char *)"function_train_alloc", _wrap_function_train_alloc, METH_VARARGS, NULL},
	 { (char *)"function_train_free", _wrap_function_train_free, METH_VARARGS, NULL},
	 { (char *)"ft_regress_run", _wrap_ft_regress_run, METH_VARARGS, NULL},
	 { (char *)"cross_validate_init", _wrap_cross_validate_init, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_aopts_alloc", _wrap_lin_elem_exp_aopts_alloc, METH_VARARGS, NULL},
	 { (char *)"function_train_eval", _wrap_function_train_eval, METH_VARARGS, NULL},
	 { (char *)"function_train_gradient_eval", _wrap_function_train_gradient_eval, METH_VARARGS, NULL},
	 { (char *)"c3approx_create", _wrap_c3approx_create, METH_VARARGS, NULL},
	 { (char *)"c3approx_destroy", _wrap_c3approx_destroy, METH_VARARGS, NULL},
	 { (char *)"c3approx_set_approx_opts_dim", _wrap_c3approx_set_approx_opts_dim, METH_VARARGS, NULL},
	 { (char *)"c3approx_set_opt_opts_dim", _wrap_c3approx_set_opt_opts_dim, METH_VARARGS, NULL},
	 { (char *)"c3approx_set_round_tol", _wrap_c3approx_set_round_tol, METH_VARARGS, NULL},
	 { (char *)"c3approx_set_verbose", _wrap_c3approx_set_verbose, METH_VARARGS, NULL},
	 { (char *)"c3approx_init_cross", _wrap_c3approx_init_cross, METH_VARARGS, NULL},
	 { (char *)"c3approx_set_cross_tol", _wrap_c3approx_set_cross_tol, METH_VARARGS, NULL},
	 { (char *)"c3approx_set_adapt_kickrank", _wrap_c3approx_set_adapt_kickrank, METH_VARARGS, NULL},
	 { (char *)"c3approx_set_adapt_maxrank_all", _wrap_c3approx_set_adapt_maxrank_all, METH_VARARGS, NULL},
	 { (char *)"c3approx_set_cross_maxiter", _wrap_c3approx_set_cross_maxiter, METH_VARARGS, NULL},
	 { (char *)"c3approx_do_cross", _wrap_c3approx_do_cross, METH_VARARGS, NULL},
	 { (char *)"c3approx_get_approx_args", _wrap_c3approx_get_approx_args, METH_VARARGS, NULL},
	 { (char *)"c3approx_get_dim", _wrap_c3approx_get_dim, METH_VARARGS, NULL},
	 { (char *)"calloc_double", _wrap_calloc_double, METH_VARARGS, NULL},
	 { (char *)"malloc_dd", _wrap_malloc_dd, METH_VARARGS, NULL},
	 { (char *)"calloc_int", _wrap_calloc_int, METH_VARARGS, NULL},
	 { (char *)"calloc_size_t", _wrap_calloc_size_t, METH_VARARGS, NULL},
	 { (char *)"copy_dd", _wrap_copy_dd, METH_VARARGS, NULL},
	 { (char *)"free_dd", _wrap_free_dd, METH_VARARGS, NULL},
	 { (char *)"dones", _wrap_dones, METH_VARARGS, NULL},
	 { (char *)"drandu", _wrap_drandu, METH_VARARGS, NULL},
	 { (char *)"darray_val", _wrap_darray_val, METH_VARARGS, NULL},
	 { (char *)"dzeros", _wrap_dzeros, METH_VARARGS, NULL},
	 { (char *)"izeros", _wrap_izeros, METH_VARARGS, NULL},
	 { (char *)"dprod", _wrap_dprod, METH_VARARGS, NULL},
	 { (char *)"iprod", _wrap_iprod, METH_VARARGS, NULL},
	 { (char *)"iprod_sz", _wrap_iprod_sz, METH_VARARGS, NULL},
	 { (char *)"dprint", _wrap_dprint, METH_VARARGS, NULL},
	 { (char *)"dprint2d", _wrap_dprint2d, METH_VARARGS, NULL},
	 { (char *)"dprint2dd", _wrap_dprint2dd, METH_VARARGS, NULL},
	 { (char *)"dprint2d_col", _wrap_dprint2d_col, METH_VARARGS, NULL},
	 { (char *)"iprint", _wrap_iprint, METH_VARARGS, NULL},
	 { (char *)"iprint_sz", _wrap_iprint_sz, METH_VARARGS, NULL},
	 { (char *)"linspace", _wrap_linspace, METH_VARARGS, NULL},
	 { (char *)"dd_row_linspace", _wrap_dd_row_linspace, METH_VARARGS, NULL},
	 { (char *)"logspace", _wrap_logspace, METH_VARARGS, NULL},
	 { (char *)"arange", _wrap_arange, METH_VARARGS, NULL},
	 { (char *)"diag", _wrap_diag, METH_VARARGS, NULL},
	 { (char *)"dconcat_cols", _wrap_dconcat_cols, METH_VARARGS, NULL},
	 { (char *)"serialize_double_to_text", _wrap_serialize_double_to_text, METH_VARARGS, NULL},
	 { (char *)"deserialize_double_from_text", _wrap_deserialize_double_from_text, METH_VARARGS, NULL},
	 { (char *)"serialize_darray_to_text", _wrap_serialize_darray_to_text, METH_VARARGS, NULL},
	 { (char *)"deserialize_darray_from_text", _wrap_deserialize_darray_from_text, METH_VARARGS, NULL},
	 { (char *)"serialize_double_packed", _wrap_serialize_double_packed, METH_VARARGS, NULL},
	 { (char *)"deserialize_double_packed", _wrap_deserialize_double_packed, METH_VARARGS, NULL},
	 { (char *)"serialize_double_arr_packed", _wrap_serialize_double_arr_packed, METH_VARARGS, NULL},
	 { (char *)"darray_save", _wrap_darray_save, METH_VARARGS, NULL},
	 { (char *)"darray_load", _wrap_darray_load, METH_VARARGS, NULL},
	 { (char *)"c3Vector_size_set", _wrap_c3Vector_size_set, METH_VARARGS, NULL},
	 { (char *)"c3Vector_size_get", _wrap_c3Vector_size_get, METH_VARARGS, NULL},
	 { (char *)"c3Vector_elem_set", _wrap_c3Vector_elem_set, METH_VARARGS, NULL},
	 { (char *)"c3Vector_elem_get", _wrap_c3Vector_elem_get, METH_VARARGS, NULL},
	 { (char *)"new_c3Vector", _wrap_new_c3Vector, METH_VARARGS, NULL},
	 { (char *)"delete_c3Vector", _wrap_delete_c3Vector, METH_VARARGS, NULL},
	 { (char *)"c3Vector_swigregister", c3Vector_swigregister, METH_VARARGS, NULL},
	 { (char *)"c3vector_alloc", _wrap_c3vector_alloc, METH_VARARGS, NULL},
	 { (char *)"c3vector_copy", _wrap_c3vector_copy, METH_VARARGS, NULL},
	 { (char *)"c3vector_free", _wrap_c3vector_free, METH_VARARGS, NULL},
	 { (char *)"c3vector_array_alloc", _wrap_c3vector_array_alloc, METH_VARARGS, NULL},
	 { (char *)"c3vector_array_copy", _wrap_c3vector_array_copy, METH_VARARGS, NULL},
	 { (char *)"c3vector_array_free", _wrap_c3vector_array_free, METH_VARARGS, NULL},
	 { (char *)"randu", _wrap_randu, METH_VARARGS, NULL},
	 { (char *)"randn", _wrap_randn, METH_VARARGS, NULL},
	 { (char *)"poisson", _wrap_poisson, METH_VARARGS, NULL},
	 { (char *)"strip_ends", _wrap_strip_ends, METH_VARARGS, NULL},
	 { (char *)"strip_blank_ends", _wrap_strip_blank_ends, METH_VARARGS, NULL},
	 { (char *)"bite_string", _wrap_bite_string, METH_VARARGS, NULL},
	 { (char *)"bite_string2", _wrap_bite_string2, METH_VARARGS, NULL},
	 { (char *)"parse_string", _wrap_parse_string, METH_VARARGS, NULL},
	 { (char *)"concat_string", _wrap_concat_string, METH_VARARGS, NULL},
	 { (char *)"concat_string_ow", _wrap_concat_string_ow, METH_VARARGS, NULL},
	 { (char *)"itoa", _wrap_itoa, METH_VARARGS, NULL},
	 { (char *)"serialize_char", _wrap_serialize_char, METH_VARARGS, NULL},
	 { (char *)"serialize_int", _wrap_serialize_int, METH_VARARGS, NULL},
	 { (char *)"deserialize_int", _wrap_deserialize_int, METH_VARARGS, NULL},
	 { (char *)"serialize_size_t", _wrap_serialize_size_t, METH_VARARGS, NULL},
	 { (char *)"deserialize_size_t", _wrap_deserialize_size_t, METH_VARARGS, NULL},
	 { (char *)"serialize_double", _wrap_serialize_double, METH_VARARGS, NULL},
	 { (char *)"deserialize_double", _wrap_deserialize_double, METH_VARARGS, NULL},
	 { (char *)"serialize_doublep", _wrap_serialize_doublep, METH_VARARGS, NULL},
	 { (char *)"deserialize_doublep", _wrap_deserialize_doublep, METH_VARARGS, NULL},
	 { (char *)"readtxt_double_array", _wrap_readtxt_double_array, METH_VARARGS, NULL},
	 { (char *)"readfile_double_array", _wrap_readfile_double_array, METH_VARARGS, NULL},
	 { (char *)"ft_regress_alloc", _wrap_ft_regress_alloc, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_sample_weights", _wrap_ft_regress_set_sample_weights, METH_VARARGS, NULL},
	 { (char *)"ft_regress_get_dim", _wrap_ft_regress_get_dim, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_adapt", _wrap_ft_regress_set_adapt, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_maxrank", _wrap_ft_regress_set_maxrank, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_kickrank", _wrap_ft_regress_set_kickrank, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_roundtol", _wrap_ft_regress_set_roundtol, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_kfold", _wrap_ft_regress_set_kfold, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_finalize", _wrap_ft_regress_set_finalize, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_opt_restrict", _wrap_ft_regress_set_opt_restrict, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_kristoffel", _wrap_ft_regress_set_kristoffel, METH_VARARGS, NULL},
	 { (char *)"ft_regress_free", _wrap_ft_regress_free, METH_VARARGS, NULL},
	 { (char *)"ft_regress_reset_param", _wrap_ft_regress_reset_param, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_type", _wrap_ft_regress_set_type, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_obj", _wrap_ft_regress_set_obj, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_alg_and_obj", _wrap_ft_regress_set_alg_and_obj, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_als_conv_tol", _wrap_ft_regress_set_als_conv_tol, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_max_als_sweep", _wrap_ft_regress_set_max_als_sweep, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_verbose", _wrap_ft_regress_set_verbose, METH_VARARGS, NULL},
	 { (char *)"ft_regress_set_regularization_weight", _wrap_ft_regress_set_regularization_weight, METH_VARARGS, NULL},
	 { (char *)"ft_regress_get_regularization_weight", _wrap_ft_regress_get_regularization_weight, METH_VARARGS, NULL},
	 { (char *)"ft_regress_get_nepochs", _wrap_ft_regress_get_nepochs, METH_VARARGS, NULL},
	 { (char *)"ft_regress_get_stored_fvals", _wrap_ft_regress_get_stored_fvals, METH_VARARGS, NULL},
	 { (char *)"ft_regress_get_params", _wrap_ft_regress_get_params, METH_VARARGS, NULL},
	 { (char *)"ft_regress_update_params", _wrap_ft_regress_update_params, METH_VARARGS, NULL},
	 { (char *)"ft_regress_run_rankadapt", _wrap_ft_regress_run_rankadapt, METH_VARARGS, NULL},
	 { (char *)"cross_validate_free", _wrap_cross_validate_free, METH_VARARGS, NULL},
	 { (char *)"cross_validate_run", _wrap_cross_validate_run, METH_VARARGS, NULL},
	 { (char *)"cv_opt_grid_init", _wrap_cv_opt_grid_init, METH_VARARGS, NULL},
	 { (char *)"cv_opt_grid_free", _wrap_cv_opt_grid_free, METH_VARARGS, NULL},
	 { (char *)"cv_opt_grid_set_verbose", _wrap_cv_opt_grid_set_verbose, METH_VARARGS, NULL},
	 { (char *)"cv_opt_grid_add_param", _wrap_cv_opt_grid_add_param, METH_VARARGS, NULL},
	 { (char *)"cross_validate_grid_opt", _wrap_cross_validate_grid_opt, METH_VARARGS, NULL},
	 { (char *)"c3_regression_run", _wrap_c3_regression_run, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_type_set", _wrap_RegressOpts_type_set, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_type_get", _wrap_RegressOpts_type_get, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_obj_set", _wrap_RegressOpts_obj_set, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_obj_get", _wrap_RegressOpts_obj_get, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_dim_set", _wrap_RegressOpts_dim_set, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_dim_get", _wrap_RegressOpts_dim_get, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_verbose_set", _wrap_RegressOpts_verbose_set, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_verbose_get", _wrap_RegressOpts_verbose_get, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_regularization_weight_set", _wrap_RegressOpts_regularization_weight_set, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_regularization_weight_get", _wrap_RegressOpts_regularization_weight_get, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_max_als_sweeps_set", _wrap_RegressOpts_max_als_sweeps_set, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_max_als_sweeps_get", _wrap_RegressOpts_max_als_sweeps_get, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_als_active_core_set", _wrap_RegressOpts_als_active_core_set, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_als_active_core_get", _wrap_RegressOpts_als_active_core_get, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_als_conv_tol_set", _wrap_RegressOpts_als_conv_tol_set, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_als_conv_tol_get", _wrap_RegressOpts_als_conv_tol_get, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_restrict_rank_opt_set", _wrap_RegressOpts_restrict_rank_opt_set, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_restrict_rank_opt_get", _wrap_RegressOpts_restrict_rank_opt_get, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_kristoffel_active_set", _wrap_RegressOpts_kristoffel_active_set, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_kristoffel_active_get", _wrap_RegressOpts_kristoffel_active_get, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_nepochs_set", _wrap_RegressOpts_nepochs_set, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_nepochs_get", _wrap_RegressOpts_nepochs_get, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_stored_fvals_set", _wrap_RegressOpts_stored_fvals_set, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_stored_fvals_get", _wrap_RegressOpts_stored_fvals_get, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_sample_weights_set", _wrap_RegressOpts_sample_weights_set, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_sample_weights_get", _wrap_RegressOpts_sample_weights_get, METH_VARARGS, NULL},
	 { (char *)"new_RegressOpts", _wrap_new_RegressOpts, METH_VARARGS, NULL},
	 { (char *)"delete_RegressOpts", _wrap_delete_RegressOpts, METH_VARARGS, NULL},
	 { (char *)"RegressOpts_swigregister", RegressOpts_swigregister, METH_VARARGS, NULL},
	 { (char *)"regress_opts_alloc", _wrap_regress_opts_alloc, METH_VARARGS, NULL},
	 { (char *)"regress_opts_free", _wrap_regress_opts_free, METH_VARARGS, NULL},
	 { (char *)"regress_opts_create", _wrap_regress_opts_create, METH_VARARGS, NULL},
	 { (char *)"regress_opts_set_sample_weights", _wrap_regress_opts_set_sample_weights, METH_VARARGS, NULL},
	 { (char *)"regress_opts_set_max_als_sweep", _wrap_regress_opts_set_max_als_sweep, METH_VARARGS, NULL},
	 { (char *)"regress_opts_set_kristoffel", _wrap_regress_opts_set_kristoffel, METH_VARARGS, NULL},
	 { (char *)"regress_opts_set_als_conv_tol", _wrap_regress_opts_set_als_conv_tol, METH_VARARGS, NULL},
	 { (char *)"regress_opts_set_verbose", _wrap_regress_opts_set_verbose, METH_VARARGS, NULL},
	 { (char *)"regress_opts_set_restrict_rank", _wrap_regress_opts_set_restrict_rank, METH_VARARGS, NULL},
	 { (char *)"regress_opts_set_regularization_weight", _wrap_regress_opts_set_regularization_weight, METH_VARARGS, NULL},
	 { (char *)"regress_opts_get_regularization_weight", _wrap_regress_opts_get_regularization_weight, METH_VARARGS, NULL},
	 { (char *)"regress_opts_add_stored_vals", _wrap_regress_opts_add_stored_vals, METH_VARARGS, NULL},
	 { (char *)"regress_opts_get_nepochs", _wrap_regress_opts_get_nepochs, METH_VARARGS, NULL},
	 { (char *)"regress_opts_get_stored_fvals", _wrap_regress_opts_get_stored_fvals, METH_VARARGS, NULL},
	 { (char *)"objective_function_add", _wrap_objective_function_add, METH_VARARGS, NULL},
	 { (char *)"objective_function_free", _wrap_objective_function_free, METH_VARARGS, NULL},
	 { (char *)"objective_eval", _wrap_objective_eval, METH_VARARGS, NULL},
	 { (char *)"LeastSquaresArgs_mapping_set", _wrap_LeastSquaresArgs_mapping_set, METH_VARARGS, NULL},
	 { (char *)"LeastSquaresArgs_mapping_get", _wrap_LeastSquaresArgs_mapping_get, METH_VARARGS, NULL},
	 { (char *)"LeastSquaresArgs_args_set", _wrap_LeastSquaresArgs_args_set, METH_VARARGS, NULL},
	 { (char *)"LeastSquaresArgs_args_get", _wrap_LeastSquaresArgs_args_get, METH_VARARGS, NULL},
	 { (char *)"new_LeastSquaresArgs", _wrap_new_LeastSquaresArgs, METH_VARARGS, NULL},
	 { (char *)"delete_LeastSquaresArgs", _wrap_delete_LeastSquaresArgs, METH_VARARGS, NULL},
	 { (char *)"LeastSquaresArgs_swigregister", LeastSquaresArgs_swigregister, METH_VARARGS, NULL},
	 { (char *)"c3_objective_function_least_squares", _wrap_c3_objective_function_least_squares, METH_VARARGS, NULL},
	 { (char *)"FTparam_ft_set", _wrap_FTparam_ft_set, METH_VARARGS, NULL},
	 { (char *)"FTparam_ft_get", _wrap_FTparam_ft_get, METH_VARARGS, NULL},
	 { (char *)"FTparam_dim_set", _wrap_FTparam_dim_set, METH_VARARGS, NULL},
	 { (char *)"FTparam_dim_get", _wrap_FTparam_dim_get, METH_VARARGS, NULL},
	 { (char *)"FTparam_nparams_per_uni_set", _wrap_FTparam_nparams_per_uni_set, METH_VARARGS, NULL},
	 { (char *)"FTparam_nparams_per_uni_get", _wrap_FTparam_nparams_per_uni_get, METH_VARARGS, NULL},
	 { (char *)"FTparam_nparams_per_core_set", _wrap_FTparam_nparams_per_core_set, METH_VARARGS, NULL},
	 { (char *)"FTparam_nparams_per_core_get", _wrap_FTparam_nparams_per_core_get, METH_VARARGS, NULL},
	 { (char *)"FTparam_max_param_uni_set", _wrap_FTparam_max_param_uni_set, METH_VARARGS, NULL},
	 { (char *)"FTparam_max_param_uni_get", _wrap_FTparam_max_param_uni_get, METH_VARARGS, NULL},
	 { (char *)"FTparam_nparams_set", _wrap_FTparam_nparams_set, METH_VARARGS, NULL},
	 { (char *)"FTparam_nparams_get", _wrap_FTparam_nparams_get, METH_VARARGS, NULL},
	 { (char *)"FTparam_params_set", _wrap_FTparam_params_set, METH_VARARGS, NULL},
	 { (char *)"FTparam_params_get", _wrap_FTparam_params_get, METH_VARARGS, NULL},
	 { (char *)"FTparam_approx_opts_set", _wrap_FTparam_approx_opts_set, METH_VARARGS, NULL},
	 { (char *)"FTparam_approx_opts_get", _wrap_FTparam_approx_opts_get, METH_VARARGS, NULL},
	 { (char *)"new_FTparam", _wrap_new_FTparam, METH_VARARGS, NULL},
	 { (char *)"delete_FTparam", _wrap_delete_FTparam, METH_VARARGS, NULL},
	 { (char *)"FTparam_swigregister", FTparam_swigregister, METH_VARARGS, NULL},
	 { (char *)"ft_param_alloc", _wrap_ft_param_alloc, METH_VARARGS, NULL},
	 { (char *)"ft_param_free", _wrap_ft_param_free, METH_VARARGS, NULL},
	 { (char *)"ft_param_get_param", _wrap_ft_param_get_param, METH_VARARGS, NULL},
	 { (char *)"ft_param_get_nparams", _wrap_ft_param_get_nparams, METH_VARARGS, NULL},
	 { (char *)"ft_param_get_nparams_restrict", _wrap_ft_param_get_nparams_restrict, METH_VARARGS, NULL},
	 { (char *)"ft_param_get_nparams_per_core", _wrap_ft_param_get_nparams_per_core, METH_VARARGS, NULL},
	 { (char *)"ft_param_get_ft", _wrap_ft_param_get_ft, METH_VARARGS, NULL},
	 { (char *)"ft_param_create_constant", _wrap_ft_param_create_constant, METH_VARARGS, NULL},
	 { (char *)"ft_param_create_from_lin_ls", _wrap_ft_param_create_from_lin_ls, METH_VARARGS, NULL},
	 { (char *)"ft_param_update_params", _wrap_ft_param_update_params, METH_VARARGS, NULL},
	 { (char *)"ft_param_update_restricted_ranks", _wrap_ft_param_update_restricted_ranks, METH_VARARGS, NULL},
	 { (char *)"ft_param_update_inside_restricted_ranks", _wrap_ft_param_update_inside_restricted_ranks, METH_VARARGS, NULL},
	 { (char *)"ft_param_update_core_params", _wrap_ft_param_update_core_params, METH_VARARGS, NULL},
	 { (char *)"ft_param_extract_structure", _wrap_ft_param_extract_structure, METH_VARARGS, NULL},
	 { (char *)"ft_param_gradeval", _wrap_ft_param_gradeval, METH_VARARGS, NULL},
	 { (char *)"ft_param_eval_lin", _wrap_ft_param_eval_lin, METH_VARARGS, NULL},
	 { (char *)"ft_param_gradeval_lin", _wrap_ft_param_gradeval_lin, METH_VARARGS, NULL},
	 { (char *)"process_sweep_left_right", _wrap_process_sweep_left_right, METH_VARARGS, NULL},
	 { (char *)"process_sweep_right_left", _wrap_process_sweep_right_left, METH_VARARGS, NULL},
	 { (char *)"process_sweep_left_right_lin", _wrap_process_sweep_left_right_lin, METH_VARARGS, NULL},
	 { (char *)"process_sweep_right_left_lin", _wrap_process_sweep_right_left_lin, METH_VARARGS, NULL},
	 { (char *)"ft_param_core_gradeval", _wrap_ft_param_core_gradeval, METH_VARARGS, NULL},
	 { (char *)"ft_param_core_eval_lin", _wrap_ft_param_core_eval_lin, METH_VARARGS, NULL},
	 { (char *)"ft_param_core_gradeval_lin", _wrap_ft_param_core_gradeval_lin, METH_VARARGS, NULL},
	 { (char *)"ft_param_hessvec", _wrap_ft_param_hessvec, METH_VARARGS, NULL},
	 { (char *)"SLP_objective_function_set", _wrap_SLP_objective_function_set, METH_VARARGS, NULL},
	 { (char *)"SLP_objective_function_get", _wrap_SLP_objective_function_get, METH_VARARGS, NULL},
	 { (char *)"SLP_optimizer_set", _wrap_SLP_optimizer_set, METH_VARARGS, NULL},
	 { (char *)"SLP_optimizer_get", _wrap_SLP_optimizer_get, METH_VARARGS, NULL},
	 { (char *)"SLP_data_set", _wrap_SLP_data_set, METH_VARARGS, NULL},
	 { (char *)"SLP_data_get", _wrap_SLP_data_get, METH_VARARGS, NULL},
	 { (char *)"SLP_mem_set", _wrap_SLP_mem_set, METH_VARARGS, NULL},
	 { (char *)"SLP_mem_get", _wrap_SLP_mem_get, METH_VARARGS, NULL},
	 { (char *)"SLP_nparams_set", _wrap_SLP_nparams_set, METH_VARARGS, NULL},
	 { (char *)"SLP_nparams_get", _wrap_SLP_nparams_get, METH_VARARGS, NULL},
	 { (char *)"SLP_obj_min_set", _wrap_SLP_obj_min_set, METH_VARARGS, NULL},
	 { (char *)"SLP_obj_min_get", _wrap_SLP_obj_min_get, METH_VARARGS, NULL},
	 { (char *)"new_SLP", _wrap_new_SLP, METH_VARARGS, NULL},
	 { (char *)"delete_SLP", _wrap_delete_SLP, METH_VARARGS, NULL},
	 { (char *)"SLP_swigregister", SLP_swigregister, METH_VARARGS, NULL},
	 { (char *)"slp_solve", _wrap_slp_solve, METH_VARARGS, NULL},
	 { (char *)"slp_get_minimum", _wrap_slp_get_minimum, METH_VARARGS, NULL},
	 { (char *)"dmrg_diffusion_midleft", _wrap_dmrg_diffusion_midleft, METH_VARARGS, NULL},
	 { (char *)"dmrg_diffusion_lastleft", _wrap_dmrg_diffusion_lastleft, METH_VARARGS, NULL},
	 { (char *)"dmrg_diffusion_midright", _wrap_dmrg_diffusion_midright, METH_VARARGS, NULL},
	 { (char *)"dmrg_diffusion_firstright", _wrap_dmrg_diffusion_firstright, METH_VARARGS, NULL},
	 { (char *)"DmDiff_A_set", _wrap_DmDiff_A_set, METH_VARARGS, NULL},
	 { (char *)"DmDiff_A_get", _wrap_DmDiff_A_get, METH_VARARGS, NULL},
	 { (char *)"DmDiff_F_set", _wrap_DmDiff_F_set, METH_VARARGS, NULL},
	 { (char *)"DmDiff_F_get", _wrap_DmDiff_F_get, METH_VARARGS, NULL},
	 { (char *)"DmDiff_dA_set", _wrap_DmDiff_dA_set, METH_VARARGS, NULL},
	 { (char *)"DmDiff_dA_get", _wrap_DmDiff_dA_get, METH_VARARGS, NULL},
	 { (char *)"DmDiff_dF_set", _wrap_DmDiff_dF_set, METH_VARARGS, NULL},
	 { (char *)"DmDiff_dF_get", _wrap_DmDiff_dF_get, METH_VARARGS, NULL},
	 { (char *)"DmDiff_ddF_set", _wrap_DmDiff_ddF_set, METH_VARARGS, NULL},
	 { (char *)"DmDiff_ddF_get", _wrap_DmDiff_ddF_get, METH_VARARGS, NULL},
	 { (char *)"new_DmDiff", _wrap_new_DmDiff, METH_VARARGS, NULL},
	 { (char *)"delete_DmDiff", _wrap_delete_DmDiff, METH_VARARGS, NULL},
	 { (char *)"DmDiff_swigregister", DmDiff_swigregister, METH_VARARGS, NULL},
	 { (char *)"dmrg_diffusion", _wrap_dmrg_diffusion, METH_VARARGS, NULL},
	 { (char *)"exact_diffusion", _wrap_exact_diffusion, METH_VARARGS, NULL},
	 { (char *)"exact_laplace", _wrap_exact_laplace, METH_VARARGS, NULL},
	 { (char *)"exact_laplace_periodic", _wrap_exact_laplace_periodic, METH_VARARGS, NULL},
	 { (char *)"exact_laplace_op", _wrap_exact_laplace_op, METH_VARARGS, NULL},
	 { (char *)"QR_right_set", _wrap_QR_right_set, METH_VARARGS, NULL},
	 { (char *)"QR_right_get", _wrap_QR_right_get, METH_VARARGS, NULL},
	 { (char *)"QR_mat_set", _wrap_QR_mat_set, METH_VARARGS, NULL},
	 { (char *)"QR_mat_get", _wrap_QR_mat_get, METH_VARARGS, NULL},
	 { (char *)"QR_mr_set", _wrap_QR_mr_set, METH_VARARGS, NULL},
	 { (char *)"QR_mr_get", _wrap_QR_mr_get, METH_VARARGS, NULL},
	 { (char *)"QR_mc_set", _wrap_QR_mc_set, METH_VARARGS, NULL},
	 { (char *)"QR_mc_get", _wrap_QR_mc_get, METH_VARARGS, NULL},
	 { (char *)"QR_Q_set", _wrap_QR_Q_set, METH_VARARGS, NULL},
	 { (char *)"QR_Q_get", _wrap_QR_Q_get, METH_VARARGS, NULL},
	 { (char *)"new_QR", _wrap_new_QR, METH_VARARGS, NULL},
	 { (char *)"delete_QR", _wrap_delete_QR, METH_VARARGS, NULL},
	 { (char *)"QR_swigregister", QR_swigregister, METH_VARARGS, NULL},
	 { (char *)"qr_reduced", _wrap_qr_reduced, METH_VARARGS, NULL},
	 { (char *)"qr_free", _wrap_qr_free, METH_VARARGS, NULL},
	 { (char *)"qr_array_free", _wrap_qr_array_free, METH_VARARGS, NULL},
	 { (char *)"qr_array_alloc", _wrap_qr_array_alloc, METH_VARARGS, NULL},
	 { (char *)"dmrg_approx", _wrap_dmrg_approx, METH_VARARGS, NULL},
	 { (char *)"DmProd_a_set", _wrap_DmProd_a_set, METH_VARARGS, NULL},
	 { (char *)"DmProd_a_get", _wrap_DmProd_a_get, METH_VARARGS, NULL},
	 { (char *)"DmProd_b_set", _wrap_DmProd_b_set, METH_VARARGS, NULL},
	 { (char *)"DmProd_b_get", _wrap_DmProd_b_get, METH_VARARGS, NULL},
	 { (char *)"new_DmProd", _wrap_new_DmProd, METH_VARARGS, NULL},
	 { (char *)"delete_DmProd", _wrap_delete_DmProd, METH_VARARGS, NULL},
	 { (char *)"DmProd_swigregister", DmProd_swigregister, METH_VARARGS, NULL},
	 { (char *)"dmrg_product", _wrap_dmrg_product, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_dim_set", _wrap_FunctionTrain_dim_set, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_dim_get", _wrap_FunctionTrain_dim_get, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_ranks_set", _wrap_FunctionTrain_ranks_set, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_ranks_get", _wrap_FunctionTrain_ranks_get, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_cores_set", _wrap_FunctionTrain_cores_set, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_cores_get", _wrap_FunctionTrain_cores_get, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evalspace1_set", _wrap_FunctionTrain_evalspace1_set, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evalspace1_get", _wrap_FunctionTrain_evalspace1_get, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evalspace2_set", _wrap_FunctionTrain_evalspace2_set, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evalspace2_get", _wrap_FunctionTrain_evalspace2_get, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evalspace3_set", _wrap_FunctionTrain_evalspace3_set, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evalspace3_get", _wrap_FunctionTrain_evalspace3_get, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evalspace4_set", _wrap_FunctionTrain_evalspace4_set, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evalspace4_get", _wrap_FunctionTrain_evalspace4_get, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evaldd1_set", _wrap_FunctionTrain_evaldd1_set, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evaldd1_get", _wrap_FunctionTrain_evaldd1_get, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evaldd2_set", _wrap_FunctionTrain_evaldd2_set, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evaldd2_get", _wrap_FunctionTrain_evaldd2_get, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evaldd3_set", _wrap_FunctionTrain_evaldd3_set, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evaldd3_get", _wrap_FunctionTrain_evaldd3_get, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evaldd4_set", _wrap_FunctionTrain_evaldd4_set, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_evaldd4_get", _wrap_FunctionTrain_evaldd4_get, METH_VARARGS, NULL},
	 { (char *)"new_FunctionTrain", _wrap_new_FunctionTrain, METH_VARARGS, NULL},
	 { (char *)"delete_FunctionTrain", _wrap_delete_FunctionTrain, METH_VARARGS, NULL},
	 { (char *)"FunctionTrain_swigregister", FunctionTrain_swigregister, METH_VARARGS, NULL},
	 { (char *)"function_train_copy", _wrap_function_train_copy, METH_VARARGS, NULL},
	 { (char *)"function_train_serialize", _wrap_function_train_serialize, METH_VARARGS, NULL},
	 { (char *)"function_train_deserialize", _wrap_function_train_deserialize, METH_VARARGS, NULL},
	 { (char *)"function_train_savetxt", _wrap_function_train_savetxt, METH_VARARGS, NULL},
	 { (char *)"function_train_loadtxt", _wrap_function_train_loadtxt, METH_VARARGS, NULL},
	 { (char *)"function_train_save", _wrap_function_train_save, METH_VARARGS, NULL},
	 { (char *)"function_train_load", _wrap_function_train_load, METH_VARARGS, NULL},
	 { (char *)"function_train_get_dim", _wrap_function_train_get_dim, METH_VARARGS, NULL},
	 { (char *)"function_train_get_ranks", _wrap_function_train_get_ranks, METH_VARARGS, NULL},
	 { (char *)"function_train_get_maxrank", _wrap_function_train_get_maxrank, METH_VARARGS, NULL},
	 { (char *)"function_train_get_avgrank", _wrap_function_train_get_avgrank, METH_VARARGS, NULL},
	 { (char *)"function_train_get_core", _wrap_function_train_get_core, METH_VARARGS, NULL},
	 { (char *)"function_train_eval_up_to_core", _wrap_function_train_eval_up_to_core, METH_VARARGS, NULL},
	 { (char *)"function_train_func_get_nparams", _wrap_function_train_func_get_nparams, METH_VARARGS, NULL},
	 { (char *)"function_train_core_get_nparams", _wrap_function_train_core_get_nparams, METH_VARARGS, NULL},
	 { (char *)"function_train_get_nparams", _wrap_function_train_get_nparams, METH_VARARGS, NULL},
	 { (char *)"function_train_core_get_params", _wrap_function_train_core_get_params, METH_VARARGS, NULL},
	 { (char *)"function_train_get_params", _wrap_function_train_get_params, METH_VARARGS, NULL},
	 { (char *)"function_train_get_uni", _wrap_function_train_get_uni, METH_VARARGS, NULL},
	 { (char *)"function_train_get_gfuni", _wrap_function_train_get_gfuni, METH_VARARGS, NULL},
	 { (char *)"function_train_uni_update_params", _wrap_function_train_uni_update_params, METH_VARARGS, NULL},
	 { (char *)"function_train_core_update_params", _wrap_function_train_core_update_params, METH_VARARGS, NULL},
	 { (char *)"function_train_update_params", _wrap_function_train_update_params, METH_VARARGS, NULL},
	 { (char *)"function_train_param_grad_sqnorm", _wrap_function_train_param_grad_sqnorm, METH_VARARGS, NULL},
	 { (char *)"function_train_eval_ind", _wrap_function_train_eval_ind, METH_VARARGS, NULL},
	 { (char *)"function_train_eval_co_perturb", _wrap_function_train_eval_co_perturb, METH_VARARGS, NULL},
	 { (char *)"function_train_eval_co_perturb_ind", _wrap_function_train_eval_co_perturb_ind, METH_VARARGS, NULL},
	 { (char *)"function_train_eval_fiber_ind", _wrap_function_train_eval_fiber_ind, METH_VARARGS, NULL},
	 { (char *)"function_train_poly_randu", _wrap_function_train_poly_randu, METH_VARARGS, NULL},
	 { (char *)"function_train_rankone", _wrap_function_train_rankone, METH_VARARGS, NULL},
	 { (char *)"function_train_initsum", _wrap_function_train_initsum, METH_VARARGS, NULL},
	 { (char *)"function_train_zeros", _wrap_function_train_zeros, METH_VARARGS, NULL},
	 { (char *)"function_train_constant", _wrap_function_train_constant, METH_VARARGS, NULL},
	 { (char *)"function_train_linear", _wrap_function_train_linear, METH_VARARGS, NULL},
	 { (char *)"function_train_linear_update", _wrap_function_train_linear_update, METH_VARARGS, NULL},
	 { (char *)"function_train_rankone_prod", _wrap_function_train_rankone_prod, METH_VARARGS, NULL},
	 { (char *)"function_train_quadratic", _wrap_function_train_quadratic, METH_VARARGS, NULL},
	 { (char *)"function_train_quadratic_aligned", _wrap_function_train_quadratic_aligned, METH_VARARGS, NULL},
	 { (char *)"function_train_create_nodal", _wrap_function_train_create_nodal, METH_VARARGS, NULL},
	 { (char *)"function_train_integrate", _wrap_function_train_integrate, METH_VARARGS, NULL},
	 { (char *)"function_train_integrate_weighted", _wrap_function_train_integrate_weighted, METH_VARARGS, NULL},
	 { (char *)"function_train_integrate_weighted_subset", _wrap_function_train_integrate_weighted_subset, METH_VARARGS, NULL},
	 { (char *)"function_train_inner", _wrap_function_train_inner, METH_VARARGS, NULL},
	 { (char *)"function_train_inner_weighted", _wrap_function_train_inner_weighted, METH_VARARGS, NULL},
	 { (char *)"function_train_norm2", _wrap_function_train_norm2, METH_VARARGS, NULL},
	 { (char *)"function_train_orthor", _wrap_function_train_orthor, METH_VARARGS, NULL},
	 { (char *)"function_train_round", _wrap_function_train_round, METH_VARARGS, NULL},
	 { (char *)"function_train_truncate", _wrap_function_train_truncate, METH_VARARGS, NULL},
	 { (char *)"function_train_sum", _wrap_function_train_sum, METH_VARARGS, NULL},
	 { (char *)"function_train_scale", _wrap_function_train_scale, METH_VARARGS, NULL},
	 { (char *)"function_train_product", _wrap_function_train_product, METH_VARARGS, NULL},
	 { (char *)"function_train_norm2diff", _wrap_function_train_norm2diff, METH_VARARGS, NULL},
	 { (char *)"function_train_relnorm2diff", _wrap_function_train_relnorm2diff, METH_VARARGS, NULL},
	 { (char *)"function_train_is_kristoffel_active", _wrap_function_train_is_kristoffel_active, METH_VARARGS, NULL},
	 { (char *)"function_train_activate_kristoffel", _wrap_function_train_activate_kristoffel, METH_VARARGS, NULL},
	 { (char *)"function_train_deactivate_kristoffel", _wrap_function_train_deactivate_kristoffel, METH_VARARGS, NULL},
	 { (char *)"function_train_get_kristoffel_weight", _wrap_function_train_get_kristoffel_weight, METH_VARARGS, NULL},
	 { (char *)"ft_cross_args_alloc", _wrap_ft_cross_args_alloc, METH_VARARGS, NULL},
	 { (char *)"ft_cross_args_set_rank", _wrap_ft_cross_args_set_rank, METH_VARARGS, NULL},
	 { (char *)"ft_cross_args_set_round_tol", _wrap_ft_cross_args_set_round_tol, METH_VARARGS, NULL},
	 { (char *)"ft_cross_args_set_kickrank", _wrap_ft_cross_args_set_kickrank, METH_VARARGS, NULL},
	 { (char *)"ft_cross_args_set_maxiter", _wrap_ft_cross_args_set_maxiter, METH_VARARGS, NULL},
	 { (char *)"ft_cross_args_set_no_adaptation", _wrap_ft_cross_args_set_no_adaptation, METH_VARARGS, NULL},
	 { (char *)"ft_cross_args_set_adaptation", _wrap_ft_cross_args_set_adaptation, METH_VARARGS, NULL},
	 { (char *)"ft_cross_args_set_maxrank_all", _wrap_ft_cross_args_set_maxrank_all, METH_VARARGS, NULL},
	 { (char *)"ft_cross_args_set_maxrank_ind", _wrap_ft_cross_args_set_maxrank_ind, METH_VARARGS, NULL},
	 { (char *)"ft_cross_args_set_cross_tol", _wrap_ft_cross_args_set_cross_tol, METH_VARARGS, NULL},
	 { (char *)"ft_cross_args_set_verbose", _wrap_ft_cross_args_set_verbose, METH_VARARGS, NULL},
	 { (char *)"ft_cross_args_get_ranks", _wrap_ft_cross_args_get_ranks, METH_VARARGS, NULL},
	 { (char *)"function_train_get_rank", _wrap_function_train_get_rank, METH_VARARGS, NULL},
	 { (char *)"ft_cross_args_copy", _wrap_ft_cross_args_copy, METH_VARARGS, NULL},
	 { (char *)"ft_cross_args_free", _wrap_ft_cross_args_free, METH_VARARGS, NULL},
	 { (char *)"function_train_init_from_fibers", _wrap_function_train_init_from_fibers, METH_VARARGS, NULL},
	 { (char *)"ftapprox_cross", _wrap_ftapprox_cross, METH_VARARGS, NULL},
	 { (char *)"ftapprox_cross_rankadapt", _wrap_ftapprox_cross_rankadapt, METH_VARARGS, NULL},
	 { (char *)"FT1DArray_size_set", _wrap_FT1DArray_size_set, METH_VARARGS, NULL},
	 { (char *)"FT1DArray_size_get", _wrap_FT1DArray_size_get, METH_VARARGS, NULL},
	 { (char *)"FT1DArray_ft_set", _wrap_FT1DArray_ft_set, METH_VARARGS, NULL},
	 { (char *)"FT1DArray_ft_get", _wrap_FT1DArray_ft_get, METH_VARARGS, NULL},
	 { (char *)"new_FT1DArray", _wrap_new_FT1DArray, METH_VARARGS, NULL},
	 { (char *)"delete_FT1DArray", _wrap_delete_FT1DArray, METH_VARARGS, NULL},
	 { (char *)"FT1DArray_swigregister", FT1DArray_swigregister, METH_VARARGS, NULL},
	 { (char *)"ft1d_array_alloc", _wrap_ft1d_array_alloc, METH_VARARGS, NULL},
	 { (char *)"function_train_gradient", _wrap_function_train_gradient, METH_VARARGS, NULL},
	 { (char *)"ft1d_array_serialize", _wrap_ft1d_array_serialize, METH_VARARGS, NULL},
	 { (char *)"ft1d_array_deserialize", _wrap_ft1d_array_deserialize, METH_VARARGS, NULL},
	 { (char *)"ft1d_array_save", _wrap_ft1d_array_save, METH_VARARGS, NULL},
	 { (char *)"ft1d_array_load", _wrap_ft1d_array_load, METH_VARARGS, NULL},
	 { (char *)"ft1d_array_copy", _wrap_ft1d_array_copy, METH_VARARGS, NULL},
	 { (char *)"ft1d_array_free", _wrap_ft1d_array_free, METH_VARARGS, NULL},
	 { (char *)"ft1d_array_jacobian", _wrap_ft1d_array_jacobian, METH_VARARGS, NULL},
	 { (char *)"function_train_hessian", _wrap_function_train_hessian, METH_VARARGS, NULL},
	 { (char *)"function_train_hessian_diag", _wrap_function_train_hessian_diag, METH_VARARGS, NULL},
	 { (char *)"function_train_hessian_diag_periodic", _wrap_function_train_hessian_diag_periodic, METH_VARARGS, NULL},
	 { (char *)"ft1d_array_scale", _wrap_ft1d_array_scale, METH_VARARGS, NULL},
	 { (char *)"ft1d_array_eval", _wrap_ft1d_array_eval, METH_VARARGS, NULL},
	 { (char *)"ft1d_array_eval2", _wrap_ft1d_array_eval2, METH_VARARGS, NULL},
	 { (char *)"c3axpy", _wrap_c3axpy, METH_VARARGS, NULL},
	 { (char *)"c3vaxpy_arr", _wrap_c3vaxpy_arr, METH_VARARGS, NULL},
	 { (char *)"c3dot", _wrap_c3dot, METH_VARARGS, NULL},
	 { (char *)"c3gemv", _wrap_c3gemv, METH_VARARGS, NULL},
	 { (char *)"c3vaxpy", _wrap_c3vaxpy, METH_VARARGS, NULL},
	 { (char *)"c3vprodsum", _wrap_c3vprodsum, METH_VARARGS, NULL},
	 { (char *)"c3vgemv", _wrap_c3vgemv, METH_VARARGS, NULL},
	 { (char *)"c3vgemv_arr", _wrap_c3vgemv_arr, METH_VARARGS, NULL},
	 { (char *)"CrossIndex_d_set", _wrap_CrossIndex_d_set, METH_VARARGS, NULL},
	 { (char *)"CrossIndex_d_get", _wrap_CrossIndex_d_get, METH_VARARGS, NULL},
	 { (char *)"CrossIndex_n_set", _wrap_CrossIndex_n_set, METH_VARARGS, NULL},
	 { (char *)"CrossIndex_n_get", _wrap_CrossIndex_n_get, METH_VARARGS, NULL},
	 { (char *)"CrossIndex_nodes_set", _wrap_CrossIndex_nodes_set, METH_VARARGS, NULL},
	 { (char *)"CrossIndex_nodes_get", _wrap_CrossIndex_nodes_get, METH_VARARGS, NULL},
	 { (char *)"new_CrossIndex", _wrap_new_CrossIndex, METH_VARARGS, NULL},
	 { (char *)"delete_CrossIndex", _wrap_delete_CrossIndex, METH_VARARGS, NULL},
	 { (char *)"CrossIndex_swigregister", CrossIndex_swigregister, METH_VARARGS, NULL},
	 { (char *)"cross_index_alloc", _wrap_cross_index_alloc, METH_VARARGS, NULL},
	 { (char *)"cross_index_free", _wrap_cross_index_free, METH_VARARGS, NULL},
	 { (char *)"cross_index_copy", _wrap_cross_index_copy, METH_VARARGS, NULL},
	 { (char *)"cross_index_add_index", _wrap_cross_index_add_index, METH_VARARGS, NULL},
	 { (char *)"cross_index_add_nested", _wrap_cross_index_add_nested, METH_VARARGS, NULL},
	 { (char *)"cross_index_get_node_value", _wrap_cross_index_get_node_value, METH_VARARGS, NULL},
	 { (char *)"cross_index_create_nested", _wrap_cross_index_create_nested, METH_VARARGS, NULL},
	 { (char *)"cross_index_create_nested_ind", _wrap_cross_index_create_nested_ind, METH_VARARGS, NULL},
	 { (char *)"cross_index_merge_wspace", _wrap_cross_index_merge_wspace, METH_VARARGS, NULL},
	 { (char *)"cross_index_merge", _wrap_cross_index_merge, METH_VARARGS, NULL},
	 { (char *)"cross_index_array_initialize", _wrap_cross_index_array_initialize, METH_VARARGS, NULL},
	 { (char *)"cross_index_copylast", _wrap_cross_index_copylast, METH_VARARGS, NULL},
	 { (char *)"print_cross_index", _wrap_print_cross_index, METH_VARARGS, NULL},
	 { (char *)"Qmarray_nrows_set", _wrap_Qmarray_nrows_set, METH_VARARGS, NULL},
	 { (char *)"Qmarray_nrows_get", _wrap_Qmarray_nrows_get, METH_VARARGS, NULL},
	 { (char *)"Qmarray_ncols_set", _wrap_Qmarray_ncols_set, METH_VARARGS, NULL},
	 { (char *)"Qmarray_ncols_get", _wrap_Qmarray_ncols_get, METH_VARARGS, NULL},
	 { (char *)"Qmarray_funcs_set", _wrap_Qmarray_funcs_set, METH_VARARGS, NULL},
	 { (char *)"Qmarray_funcs_get", _wrap_Qmarray_funcs_get, METH_VARARGS, NULL},
	 { (char *)"new_Qmarray", _wrap_new_Qmarray, METH_VARARGS, NULL},
	 { (char *)"delete_Qmarray", _wrap_delete_Qmarray, METH_VARARGS, NULL},
	 { (char *)"Qmarray_swigregister", Qmarray_swigregister, METH_VARARGS, NULL},
	 { (char *)"qmarray_alloc", _wrap_qmarray_alloc, METH_VARARGS, NULL},
	 { (char *)"qmarray_free", _wrap_qmarray_free, METH_VARARGS, NULL},
	 { (char *)"qmarray_copy", _wrap_qmarray_copy, METH_VARARGS, NULL},
	 { (char *)"qmarray_operate_elements", _wrap_qmarray_operate_elements, METH_VARARGS, NULL},
	 { (char *)"qmarray_serialize", _wrap_qmarray_serialize, METH_VARARGS, NULL},
	 { (char *)"qmarray_deserialize", _wrap_qmarray_deserialize, METH_VARARGS, NULL},
	 { (char *)"qmarray_savetxt", _wrap_qmarray_savetxt, METH_VARARGS, NULL},
	 { (char *)"qmarray_loadtxt", _wrap_qmarray_loadtxt, METH_VARARGS, NULL},
	 { (char *)"qmarray_approx1d", _wrap_qmarray_approx1d, METH_VARARGS, NULL},
	 { (char *)"qmarray_orth1d_rows", _wrap_qmarray_orth1d_rows, METH_VARARGS, NULL},
	 { (char *)"qmarray_orth1d_columns", _wrap_qmarray_orth1d_columns, METH_VARARGS, NULL},
	 { (char *)"qmarray_zeros", _wrap_qmarray_zeros, METH_VARARGS, NULL},
	 { (char *)"qmarray_poly_randu", _wrap_qmarray_poly_randu, METH_VARARGS, NULL},
	 { (char *)"qmarray_get_func_base", _wrap_qmarray_get_func_base, METH_VARARGS, NULL},
	 { (char *)"qmarray_get_func", _wrap_qmarray_get_func, METH_VARARGS, NULL},
	 { (char *)"qmarray_set_row", _wrap_qmarray_set_row, METH_VARARGS, NULL},
	 { (char *)"qmarray_extract_row", _wrap_qmarray_extract_row, METH_VARARGS, NULL},
	 { (char *)"qmarray_set_column", _wrap_qmarray_set_column, METH_VARARGS, NULL},
	 { (char *)"qmarray_set_column_gf", _wrap_qmarray_set_column_gf, METH_VARARGS, NULL},
	 { (char *)"qmarray_extract_column", _wrap_qmarray_extract_column, METH_VARARGS, NULL},
	 { (char *)"qmarray_get_ncols", _wrap_qmarray_get_ncols, METH_VARARGS, NULL},
	 { (char *)"qmarray_get_nrows", _wrap_qmarray_get_nrows, METH_VARARGS, NULL},
	 { (char *)"qmam", _wrap_qmam, METH_VARARGS, NULL},
	 { (char *)"qmatm", _wrap_qmatm, METH_VARARGS, NULL},
	 { (char *)"mqma", _wrap_mqma, METH_VARARGS, NULL},
	 { (char *)"qmaqma", _wrap_qmaqma, METH_VARARGS, NULL},
	 { (char *)"qmatqma", _wrap_qmatqma, METH_VARARGS, NULL},
	 { (char *)"qmaqmat", _wrap_qmaqmat, METH_VARARGS, NULL},
	 { (char *)"qmatqmat", _wrap_qmatqmat, METH_VARARGS, NULL},
	 { (char *)"qmatqma_integrate", _wrap_qmatqma_integrate, METH_VARARGS, NULL},
	 { (char *)"qmaqmat_integrate", _wrap_qmaqmat_integrate, METH_VARARGS, NULL},
	 { (char *)"qmatqmat_integrate_weighted", _wrap_qmatqmat_integrate_weighted, METH_VARARGS, NULL},
	 { (char *)"qmatqmat_integrate", _wrap_qmatqmat_integrate, METH_VARARGS, NULL},
	 { (char *)"qmarray_kron", _wrap_qmarray_kron, METH_VARARGS, NULL},
	 { (char *)"qmarray_kron_integrate", _wrap_qmarray_kron_integrate, METH_VARARGS, NULL},
	 { (char *)"qmarray_kron_integrate_weighted", _wrap_qmarray_kron_integrate_weighted, METH_VARARGS, NULL},
	 { (char *)"qmarray_vec_kron", _wrap_qmarray_vec_kron, METH_VARARGS, NULL},
	 { (char *)"qmarray_vec_kron_integrate", _wrap_qmarray_vec_kron_integrate, METH_VARARGS, NULL},
	 { (char *)"qmarray_vec_kron_integrate_weighted", _wrap_qmarray_vec_kron_integrate_weighted, METH_VARARGS, NULL},
	 { (char *)"qmarray_mat_kron", _wrap_qmarray_mat_kron, METH_VARARGS, NULL},
	 { (char *)"qmarray_kron_mat", _wrap_qmarray_kron_mat, METH_VARARGS, NULL},
	 { (char *)"qmarray_block_kron_mat", _wrap_qmarray_block_kron_mat, METH_VARARGS, NULL},
	 { (char *)"qmarray_integrate", _wrap_qmarray_integrate, METH_VARARGS, NULL},
	 { (char *)"qmarray_integrate_weighted", _wrap_qmarray_integrate_weighted, METH_VARARGS, NULL},
	 { (char *)"qmarray_norm2diff", _wrap_qmarray_norm2diff, METH_VARARGS, NULL},
	 { (char *)"qmarray_norm2", _wrap_qmarray_norm2, METH_VARARGS, NULL},
	 { (char *)"qmarray_axpy", _wrap_qmarray_axpy, METH_VARARGS, NULL},
	 { (char *)"qmarray_lu1d", _wrap_qmarray_lu1d, METH_VARARGS, NULL},
	 { (char *)"qmarray_maxvol1d", _wrap_qmarray_maxvol1d, METH_VARARGS, NULL},
	 { (char *)"qmarray_qhouse", _wrap_qmarray_qhouse, METH_VARARGS, NULL},
	 { (char *)"qmarray_qhouse_rows", _wrap_qmarray_qhouse_rows, METH_VARARGS, NULL},
	 { (char *)"qmarray_householder", _wrap_qmarray_householder, METH_VARARGS, NULL},
	 { (char *)"qmarray_householder_rows", _wrap_qmarray_householder_rows, METH_VARARGS, NULL},
	 { (char *)"qmarray_householder_simple", _wrap_qmarray_householder_simple, METH_VARARGS, NULL},
	 { (char *)"qmarray_svd", _wrap_qmarray_svd, METH_VARARGS, NULL},
	 { (char *)"qmarray_truncated_svd", _wrap_qmarray_truncated_svd, METH_VARARGS, NULL},
	 { (char *)"qmarray_absmax1d", _wrap_qmarray_absmax1d, METH_VARARGS, NULL},
	 { (char *)"qmarray_transpose", _wrap_qmarray_transpose, METH_VARARGS, NULL},
	 { (char *)"qmarray_stackh", _wrap_qmarray_stackh, METH_VARARGS, NULL},
	 { (char *)"qmarray_stackv", _wrap_qmarray_stackv, METH_VARARGS, NULL},
	 { (char *)"qmarray_blockdiag", _wrap_qmarray_blockdiag, METH_VARARGS, NULL},
	 { (char *)"qmarray_deriv", _wrap_qmarray_deriv, METH_VARARGS, NULL},
	 { (char *)"qmarray_dderiv", _wrap_qmarray_dderiv, METH_VARARGS, NULL},
	 { (char *)"qmarray_dderiv_periodic", _wrap_qmarray_dderiv_periodic, METH_VARARGS, NULL},
	 { (char *)"qmarray_deriv_eval", _wrap_qmarray_deriv_eval, METH_VARARGS, NULL},
	 { (char *)"qmarray_roundt", _wrap_qmarray_roundt, METH_VARARGS, NULL},
	 { (char *)"qmarray_eval", _wrap_qmarray_eval, METH_VARARGS, NULL},
	 { (char *)"qmarray_func_get_nparams", _wrap_qmarray_func_get_nparams, METH_VARARGS, NULL},
	 { (char *)"qmarray_get_nparams", _wrap_qmarray_get_nparams, METH_VARARGS, NULL},
	 { (char *)"qmarray_get_params", _wrap_qmarray_get_params, METH_VARARGS, NULL},
	 { (char *)"qmarray_uni_update_params", _wrap_qmarray_uni_update_params, METH_VARARGS, NULL},
	 { (char *)"qmarray_update_params", _wrap_qmarray_update_params, METH_VARARGS, NULL},
	 { (char *)"qmarray_param_grad_eval", _wrap_qmarray_param_grad_eval, METH_VARARGS, NULL},
	 { (char *)"qmarray_linparam_eval", _wrap_qmarray_linparam_eval, METH_VARARGS, NULL},
	 { (char *)"qmarray_param_grad_eval_sparse_mult", _wrap_qmarray_param_grad_eval_sparse_mult, METH_VARARGS, NULL},
	 { (char *)"qmarray_param_grad_sqnorm", _wrap_qmarray_param_grad_sqnorm, METH_VARARGS, NULL},
	 { (char *)"qmarray_create_nodal", _wrap_qmarray_create_nodal, METH_VARARGS, NULL},
	 { (char *)"qmarray_is_kristoffel_active", _wrap_qmarray_is_kristoffel_active, METH_VARARGS, NULL},
	 { (char *)"qmarray_activate_kristoffel", _wrap_qmarray_activate_kristoffel, METH_VARARGS, NULL},
	 { (char *)"qmarray_deactivate_kristoffel", _wrap_qmarray_deactivate_kristoffel, METH_VARARGS, NULL},
	 { (char *)"qmarray_get_kristoffel_weight", _wrap_qmarray_get_kristoffel_weight, METH_VARARGS, NULL},
	 { (char *)"qmarray_qr", _wrap_qmarray_qr, METH_VARARGS, NULL},
	 { (char *)"qmarray_lq", _wrap_qmarray_lq, METH_VARARGS, NULL},
	 { (char *)"qmarray_qr_gs", _wrap_qmarray_qr_gs, METH_VARARGS, NULL},
	 { (char *)"qmarray_lq_gs", _wrap_qmarray_lq_gs, METH_VARARGS, NULL},
	 { (char *)"print_qmarray", _wrap_print_qmarray, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_alloc", _wrap_quasimatrix_alloc, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_free_funcs", _wrap_quasimatrix_free_funcs, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_free", _wrap_quasimatrix_free, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_get_size", _wrap_quasimatrix_get_size, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_set_size", _wrap_quasimatrix_set_size, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_get_func", _wrap_quasimatrix_get_func, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_set_func", _wrap_quasimatrix_set_func, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_get_funcs", _wrap_quasimatrix_get_funcs, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_set_funcs", _wrap_quasimatrix_set_funcs, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_get_funcs_ref", _wrap_quasimatrix_get_funcs_ref, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_approx1d", _wrap_quasimatrix_approx1d, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_copy", _wrap_quasimatrix_copy, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_serialize", _wrap_quasimatrix_serialize, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_deserialize", _wrap_quasimatrix_deserialize, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_orth1d", _wrap_quasimatrix_orth1d, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_absmax", _wrap_quasimatrix_absmax, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_inner", _wrap_quasimatrix_inner, METH_VARARGS, NULL},
	 { (char *)"qmv", _wrap_qmv, METH_VARARGS, NULL},
	 { (char *)"qmm", _wrap_qmm, METH_VARARGS, NULL},
	 { (char *)"qmmt", _wrap_qmmt, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_daxpby", _wrap_quasimatrix_daxpby, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_householder_simple", _wrap_quasimatrix_householder_simple, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_householder", _wrap_quasimatrix_householder, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_qhouse", _wrap_quasimatrix_qhouse, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_lu1d", _wrap_quasimatrix_lu1d, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_maxvol1d", _wrap_quasimatrix_maxvol1d, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_rank", _wrap_quasimatrix_rank, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_norm", _wrap_quasimatrix_norm, METH_VARARGS, NULL},
	 { (char *)"quasimatrix_print", _wrap_quasimatrix_print, METH_VARARGS, NULL},
	 { (char *)"OneApproxOpts_fc_set", _wrap_OneApproxOpts_fc_set, METH_VARARGS, NULL},
	 { (char *)"OneApproxOpts_fc_get", _wrap_OneApproxOpts_fc_get, METH_VARARGS, NULL},
	 { (char *)"OneApproxOpts_aopts_set", _wrap_OneApproxOpts_aopts_set, METH_VARARGS, NULL},
	 { (char *)"OneApproxOpts_aopts_get", _wrap_OneApproxOpts_aopts_get, METH_VARARGS, NULL},
	 { (char *)"new_OneApproxOpts", _wrap_new_OneApproxOpts, METH_VARARGS, NULL},
	 { (char *)"delete_OneApproxOpts", _wrap_delete_OneApproxOpts, METH_VARARGS, NULL},
	 { (char *)"OneApproxOpts_swigregister", OneApproxOpts_swigregister, METH_VARARGS, NULL},
	 { (char *)"one_approx_opts_alloc", _wrap_one_approx_opts_alloc, METH_VARARGS, NULL},
	 { (char *)"one_approx_opts_free", _wrap_one_approx_opts_free, METH_VARARGS, NULL},
	 { (char *)"one_approx_opts_free_deep", _wrap_one_approx_opts_free_deep, METH_VARARGS, NULL},
	 { (char *)"one_approx_opts_get_nparams", _wrap_one_approx_opts_get_nparams, METH_VARARGS, NULL},
	 { (char *)"one_approx_opts_set_nparams", _wrap_one_approx_opts_set_nparams, METH_VARARGS, NULL},
	 { (char *)"one_approx_opts_get_lb", _wrap_one_approx_opts_get_lb, METH_VARARGS, NULL},
	 { (char *)"one_approx_opts_get_ub", _wrap_one_approx_opts_get_ub, METH_VARARGS, NULL},
	 { (char *)"one_approx_opts_linear_p", _wrap_one_approx_opts_linear_p, METH_VARARGS, NULL},
	 { (char *)"multi_approx_opts_alloc", _wrap_multi_approx_opts_alloc, METH_VARARGS, NULL},
	 { (char *)"multi_approx_opts_free", _wrap_multi_approx_opts_free, METH_VARARGS, NULL},
	 { (char *)"multi_approx_opts_free_deep", _wrap_multi_approx_opts_free_deep, METH_VARARGS, NULL},
	 { (char *)"multi_approx_opts_set_dim", _wrap_multi_approx_opts_set_dim, METH_VARARGS, NULL},
	 { (char *)"multi_approx_opts_set_dim_ref", _wrap_multi_approx_opts_set_dim_ref, METH_VARARGS, NULL},
	 { (char *)"multi_approx_opts_set_all_same", _wrap_multi_approx_opts_set_all_same, METH_VARARGS, NULL},
	 { (char *)"multi_approx_opts_get_fc", _wrap_multi_approx_opts_get_fc, METH_VARARGS, NULL},
	 { (char *)"multi_approx_opts_linear_p", _wrap_multi_approx_opts_linear_p, METH_VARARGS, NULL},
	 { (char *)"multi_approx_opts_get_aopts", _wrap_multi_approx_opts_get_aopts, METH_VARARGS, NULL},
	 { (char *)"multi_approx_opts_get_dim", _wrap_multi_approx_opts_get_dim, METH_VARARGS, NULL},
	 { (char *)"multi_approx_opts_get_dim_nparams", _wrap_multi_approx_opts_get_dim_nparams, METH_VARARGS, NULL},
	 { (char *)"multi_approx_opts_set_dim_nparams", _wrap_multi_approx_opts_set_dim_nparams, METH_VARARGS, NULL},
	 { (char *)"multi_approx_opts_get_dim_ub", _wrap_multi_approx_opts_get_dim_ub, METH_VARARGS, NULL},
	 { (char *)"multi_approx_opts_get_dim_lb", _wrap_multi_approx_opts_get_dim_lb, METH_VARARGS, NULL},
	 { (char *)"fiber_opt_args_alloc", _wrap_fiber_opt_args_alloc, METH_VARARGS, NULL},
	 { (char *)"fiber_opt_args_init", _wrap_fiber_opt_args_init, METH_VARARGS, NULL},
	 { (char *)"fiber_opt_args_set_dim", _wrap_fiber_opt_args_set_dim, METH_VARARGS, NULL},
	 { (char *)"fiber_opt_args_bf", _wrap_fiber_opt_args_bf, METH_VARARGS, NULL},
	 { (char *)"fiber_opt_args_bf_same", _wrap_fiber_opt_args_bf_same, METH_VARARGS, NULL},
	 { (char *)"fiber_opt_args_get_opts", _wrap_fiber_opt_args_get_opts, METH_VARARGS, NULL},
	 { (char *)"fiber_opt_args_free", _wrap_fiber_opt_args_free, METH_VARARGS, NULL},
	 { (char *)"Operator_f_set", _wrap_Operator_f_set, METH_VARARGS, NULL},
	 { (char *)"Operator_f_get", _wrap_Operator_f_get, METH_VARARGS, NULL},
	 { (char *)"Operator_opts_set", _wrap_Operator_opts_set, METH_VARARGS, NULL},
	 { (char *)"Operator_opts_get", _wrap_Operator_opts_get, METH_VARARGS, NULL},
	 { (char *)"new_Operator", _wrap_new_Operator, METH_VARARGS, NULL},
	 { (char *)"delete_Operator", _wrap_delete_Operator, METH_VARARGS, NULL},
	 { (char *)"Operator_swigregister", Operator_swigregister, METH_VARARGS, NULL},
	 { (char *)"GenericFunction_dim_set", _wrap_GenericFunction_dim_set, METH_VARARGS, NULL},
	 { (char *)"GenericFunction_dim_get", _wrap_GenericFunction_dim_get, METH_VARARGS, NULL},
	 { (char *)"GenericFunction_fc_set", _wrap_GenericFunction_fc_set, METH_VARARGS, NULL},
	 { (char *)"GenericFunction_fc_get", _wrap_GenericFunction_fc_get, METH_VARARGS, NULL},
	 { (char *)"GenericFunction_f_set", _wrap_GenericFunction_f_set, METH_VARARGS, NULL},
	 { (char *)"GenericFunction_f_get", _wrap_GenericFunction_f_get, METH_VARARGS, NULL},
	 { (char *)"GenericFunction_fargs_set", _wrap_GenericFunction_fargs_set, METH_VARARGS, NULL},
	 { (char *)"GenericFunction_fargs_get", _wrap_GenericFunction_fargs_get, METH_VARARGS, NULL},
	 { (char *)"new_GenericFunction", _wrap_new_GenericFunction, METH_VARARGS, NULL},
	 { (char *)"delete_GenericFunction", _wrap_delete_GenericFunction, METH_VARARGS, NULL},
	 { (char *)"GenericFunction_swigregister", GenericFunction_swigregister, METH_VARARGS, NULL},
	 { (char *)"generic_function_alloc_base", _wrap_generic_function_alloc_base, METH_VARARGS, NULL},
	 { (char *)"generic_function_array_alloc", _wrap_generic_function_array_alloc, METH_VARARGS, NULL},
	 { (char *)"generic_function_alloc", _wrap_generic_function_alloc, METH_VARARGS, NULL},
	 { (char *)"generic_function_free", _wrap_generic_function_free, METH_VARARGS, NULL},
	 { (char *)"generic_function_array_free", _wrap_generic_function_array_free, METH_VARARGS, NULL},
	 { (char *)"generic_function_copy", _wrap_generic_function_copy, METH_VARARGS, NULL},
	 { (char *)"generic_function_copy_pa", _wrap_generic_function_copy_pa, METH_VARARGS, NULL},
	 { (char *)"serialize_generic_function", _wrap_serialize_generic_function, METH_VARARGS, NULL},
	 { (char *)"deserialize_generic_function", _wrap_deserialize_generic_function, METH_VARARGS, NULL},
	 { (char *)"generic_function_savetxt", _wrap_generic_function_savetxt, METH_VARARGS, NULL},
	 { (char *)"generic_function_loadtxt", _wrap_generic_function_loadtxt, METH_VARARGS, NULL},
	 { (char *)"print_generic_function", _wrap_print_generic_function, METH_VARARGS, NULL},
	 { (char *)"generic_function_approximate1d", _wrap_generic_function_approximate1d, METH_VARARGS, NULL},
	 { (char *)"generic_function_regress1d", _wrap_generic_function_regress1d, METH_VARARGS, NULL},
	 { (char *)"generic_function_create_with_params", _wrap_generic_function_create_with_params, METH_VARARGS, NULL},
	 { (char *)"generic_function_zero", _wrap_generic_function_zero, METH_VARARGS, NULL},
	 { (char *)"generic_function_constant", _wrap_generic_function_constant, METH_VARARGS, NULL},
	 { (char *)"generic_function_linear", _wrap_generic_function_linear, METH_VARARGS, NULL},
	 { (char *)"generic_function_linear_update", _wrap_generic_function_linear_update, METH_VARARGS, NULL},
	 { (char *)"generic_function_quadratic", _wrap_generic_function_quadratic, METH_VARARGS, NULL},
	 { (char *)"generic_function_poly_randu", _wrap_generic_function_poly_randu, METH_VARARGS, NULL},
	 { (char *)"generic_function_onezero", _wrap_generic_function_onezero, METH_VARARGS, NULL},
	 { (char *)"generic_function_lin_comb", _wrap_generic_function_lin_comb, METH_VARARGS, NULL},
	 { (char *)"generic_function_lin_comb2", _wrap_generic_function_lin_comb2, METH_VARARGS, NULL},
	 { (char *)"generic_function_deriv", _wrap_generic_function_deriv, METH_VARARGS, NULL},
	 { (char *)"generic_function_dderiv", _wrap_generic_function_dderiv, METH_VARARGS, NULL},
	 { (char *)"generic_function_dderiv_periodic", _wrap_generic_function_dderiv_periodic, METH_VARARGS, NULL},
	 { (char *)"generic_function_create_nodal", _wrap_generic_function_create_nodal, METH_VARARGS, NULL},
	 { (char *)"generic_function_sum_prod", _wrap_generic_function_sum_prod, METH_VARARGS, NULL},
	 { (char *)"generic_function_prod", _wrap_generic_function_prod, METH_VARARGS, NULL},
	 { (char *)"generic_function_daxpby", _wrap_generic_function_daxpby, METH_VARARGS, NULL},
	 { (char *)"generic_function_array_daxpby", _wrap_generic_function_array_daxpby, METH_VARARGS, NULL},
	 { (char *)"generic_function_get_num_params", _wrap_generic_function_get_num_params, METH_VARARGS, NULL},
	 { (char *)"generic_function_get_lb", _wrap_generic_function_get_lb, METH_VARARGS, NULL},
	 { (char *)"generic_function_get_ub", _wrap_generic_function_get_ub, METH_VARARGS, NULL},
	 { (char *)"generic_function_get_fc", _wrap_generic_function_get_fc, METH_VARARGS, NULL},
	 { (char *)"generic_function_is_kristoffel_active", _wrap_generic_function_is_kristoffel_active, METH_VARARGS, NULL},
	 { (char *)"generic_function_activate_kristoffel", _wrap_generic_function_activate_kristoffel, METH_VARARGS, NULL},
	 { (char *)"generic_function_deactivate_kristoffel", _wrap_generic_function_deactivate_kristoffel, METH_VARARGS, NULL},
	 { (char *)"generic_function_get_kristoffel_weight", _wrap_generic_function_get_kristoffel_weight, METH_VARARGS, NULL},
	 { (char *)"generic_function_get_params", _wrap_generic_function_get_params, METH_VARARGS, NULL},
	 { (char *)"generic_function_get_params_ref", _wrap_generic_function_get_params_ref, METH_VARARGS, NULL},
	 { (char *)"generic_function_update_params", _wrap_generic_function_update_params, METH_VARARGS, NULL},
	 { (char *)"generic_function_roundt", _wrap_generic_function_roundt, METH_VARARGS, NULL},
	 { (char *)"generic_function_array_onezero", _wrap_generic_function_array_onezero, METH_VARARGS, NULL},
	 { (char *)"generic_function_flip_sign", _wrap_generic_function_flip_sign, METH_VARARGS, NULL},
	 { (char *)"generic_function_array_flip_sign", _wrap_generic_function_array_flip_sign, METH_VARARGS, NULL},
	 { (char *)"generic_function_weighted_sum_pa", _wrap_generic_function_weighted_sum_pa, METH_VARARGS, NULL},
	 { (char *)"generic_function_sum3_up", _wrap_generic_function_sum3_up, METH_VARARGS, NULL},
	 { (char *)"generic_function_axpy", _wrap_generic_function_axpy, METH_VARARGS, NULL},
	 { (char *)"generic_function_array_axpy", _wrap_generic_function_array_axpy, METH_VARARGS, NULL},
	 { (char *)"generic_function_scale", _wrap_generic_function_scale, METH_VARARGS, NULL},
	 { (char *)"generic_function_array_scale", _wrap_generic_function_array_scale, METH_VARARGS, NULL},
	 { (char *)"generic_function_kronh", _wrap_generic_function_kronh, METH_VARARGS, NULL},
	 { (char *)"generic_function_kronh2", _wrap_generic_function_kronh2, METH_VARARGS, NULL},
	 { (char *)"generic_function_array_orth", _wrap_generic_function_array_orth, METH_VARARGS, NULL},
	 { (char *)"generic_function_array_daxpby2", _wrap_generic_function_array_daxpby2, METH_VARARGS, NULL},
	 { (char *)"generic_function_1d_eval", _wrap_generic_function_1d_eval, METH_VARARGS, NULL},
	 { (char *)"generic_function_deriv_eval", _wrap_generic_function_deriv_eval, METH_VARARGS, NULL},
	 { (char *)"generic_function_1d_evalN", _wrap_generic_function_1d_evalN, METH_VARARGS, NULL},
	 { (char *)"generic_function_1d_eval_ind", _wrap_generic_function_1d_eval_ind, METH_VARARGS, NULL},
	 { (char *)"generic_function_1darray_eval", _wrap_generic_function_1darray_eval, METH_VARARGS, NULL},
	 { (char *)"generic_function_1darray_eval_piv", _wrap_generic_function_1darray_eval_piv, METH_VARARGS, NULL},
	 { (char *)"generic_function_1darray_eval2", _wrap_generic_function_1darray_eval2, METH_VARARGS, NULL},
	 { (char *)"generic_function_1darray_eval2N", _wrap_generic_function_1darray_eval2N, METH_VARARGS, NULL},
	 { (char *)"generic_function_1darray_eval2_ind", _wrap_generic_function_1darray_eval2_ind, METH_VARARGS, NULL},
	 { (char *)"generic_function_param_grad_eval", _wrap_generic_function_param_grad_eval, METH_VARARGS, NULL},
	 { (char *)"generic_function_param_grad_eval2", _wrap_generic_function_param_grad_eval2, METH_VARARGS, NULL},
	 { (char *)"generic_function_integrate", _wrap_generic_function_integrate, METH_VARARGS, NULL},
	 { (char *)"generic_function_integrate_weighted", _wrap_generic_function_integrate_weighted, METH_VARARGS, NULL},
	 { (char *)"generic_function_norm", _wrap_generic_function_norm, METH_VARARGS, NULL},
	 { (char *)"generic_function_inner", _wrap_generic_function_inner, METH_VARARGS, NULL},
	 { (char *)"generic_function_inner_weighted", _wrap_generic_function_inner_weighted, METH_VARARGS, NULL},
	 { (char *)"generic_function_inner_sum", _wrap_generic_function_inner_sum, METH_VARARGS, NULL},
	 { (char *)"generic_function_inner_weighted_sum", _wrap_generic_function_inner_weighted_sum, METH_VARARGS, NULL},
	 { (char *)"generic_function_norm2diff", _wrap_generic_function_norm2diff, METH_VARARGS, NULL},
	 { (char *)"generic_function_array_norm2diff", _wrap_generic_function_array_norm2diff, METH_VARARGS, NULL},
	 { (char *)"generic_function_integral_array", _wrap_generic_function_integral_array, METH_VARARGS, NULL},
	 { (char *)"generic_function_array_norm", _wrap_generic_function_array_norm, METH_VARARGS, NULL},
	 { (char *)"generic_function_absmax", _wrap_generic_function_absmax, METH_VARARGS, NULL},
	 { (char *)"generic_function_absmax_gen", _wrap_generic_function_absmax_gen, METH_VARARGS, NULL},
	 { (char *)"generic_function_array_absmax", _wrap_generic_function_array_absmax, METH_VARARGS, NULL},
	 { (char *)"generic_function_array_absmax_piv", _wrap_generic_function_array_absmax_piv, METH_VARARGS, NULL},
	 { (char *)"regress_1d_opts_create", _wrap_regress_1d_opts_create, METH_VARARGS, NULL},
	 { (char *)"regress_1d_opts_destroy", _wrap_regress_1d_opts_destroy, METH_VARARGS, NULL},
	 { (char *)"regress_1d_opts_set_parametric_form", _wrap_regress_1d_opts_set_parametric_form, METH_VARARGS, NULL},
	 { (char *)"regress_1d_opts_set_initial_parameters", _wrap_regress_1d_opts_set_initial_parameters, METH_VARARGS, NULL},
	 { (char *)"generic_function_squared_norm_param_grad", _wrap_generic_function_squared_norm_param_grad, METH_VARARGS, NULL},
	 { (char *)"regress_1d_opts_set_regularization_penalty", _wrap_regress_1d_opts_set_regularization_penalty, METH_VARARGS, NULL},
	 { (char *)"regress_1d_opts_set_RKHS_decay_rate", _wrap_regress_1d_opts_set_RKHS_decay_rate, METH_VARARGS, NULL},
	 { (char *)"param_LSregress_cost", _wrap_param_LSregress_cost, METH_VARARGS, NULL},
	 { (char *)"param_RLS2regress_cost", _wrap_param_RLS2regress_cost, METH_VARARGS, NULL},
	 { (char *)"param_RLSD2regress_cost", _wrap_param_RLSD2regress_cost, METH_VARARGS, NULL},
	 { (char *)"param_RLSRKHSregress_cost", _wrap_param_RLSRKHSregress_cost, METH_VARARGS, NULL},
	 { (char *)"FiberCut_fpoint_set", _wrap_FiberCut_fpoint_set, METH_VARARGS, NULL},
	 { (char *)"FiberCut_fpoint_get", _wrap_FiberCut_fpoint_get, METH_VARARGS, NULL},
	 { (char *)"FiberCut_totdim_set", _wrap_FiberCut_totdim_set, METH_VARARGS, NULL},
	 { (char *)"FiberCut_totdim_get", _wrap_FiberCut_totdim_get, METH_VARARGS, NULL},
	 { (char *)"FiberCut_dimcut_set", _wrap_FiberCut_dimcut_set, METH_VARARGS, NULL},
	 { (char *)"FiberCut_dimcut_get", _wrap_FiberCut_dimcut_get, METH_VARARGS, NULL},
	 { (char *)"FiberCut_ftype_flag_set", _wrap_FiberCut_ftype_flag_set, METH_VARARGS, NULL},
	 { (char *)"FiberCut_ftype_flag_get", _wrap_FiberCut_ftype_flag_get, METH_VARARGS, NULL},
	 { (char *)"FiberCut_args_set", _wrap_FiberCut_args_set, METH_VARARGS, NULL},
	 { (char *)"FiberCut_args_get", _wrap_FiberCut_args_get, METH_VARARGS, NULL},
	 { (char *)"FiberCut_vals_set", _wrap_FiberCut_vals_set, METH_VARARGS, NULL},
	 { (char *)"FiberCut_vals_get", _wrap_FiberCut_vals_get, METH_VARARGS, NULL},
	 { (char *)"new_FiberCut", _wrap_new_FiberCut, METH_VARARGS, NULL},
	 { (char *)"delete_FiberCut", _wrap_delete_FiberCut, METH_VARARGS, NULL},
	 { (char *)"FiberCut_swigregister", FiberCut_swigregister, METH_VARARGS, NULL},
	 { (char *)"func_type_fnd_set", _wrap_func_type_fnd_set, METH_VARARGS, NULL},
	 { (char *)"func_type_fnd_get", _wrap_func_type_fnd_get, METH_VARARGS, NULL},
	 { (char *)"func_type_f2d_set", _wrap_func_type_f2d_set, METH_VARARGS, NULL},
	 { (char *)"func_type_f2d_get", _wrap_func_type_f2d_get, METH_VARARGS, NULL},
	 { (char *)"new_func_type", _wrap_new_func_type, METH_VARARGS, NULL},
	 { (char *)"delete_func_type", _wrap_delete_func_type, METH_VARARGS, NULL},
	 { (char *)"func_type_swigregister", func_type_swigregister, METH_VARARGS, NULL},
	 { (char *)"fiber_cut_init2d", _wrap_fiber_cut_init2d, METH_VARARGS, NULL},
	 { (char *)"fiber_cut_2darray", _wrap_fiber_cut_2darray, METH_VARARGS, NULL},
	 { (char *)"fiber_cut_ndarray", _wrap_fiber_cut_ndarray, METH_VARARGS, NULL},
	 { (char *)"fiber_cut_free", _wrap_fiber_cut_free, METH_VARARGS, NULL},
	 { (char *)"fiber_cut_array_free", _wrap_fiber_cut_array_free, METH_VARARGS, NULL},
	 { (char *)"fiber_cut_eval2d", _wrap_fiber_cut_eval2d, METH_VARARGS, NULL},
	 { (char *)"fiber_cut_eval", _wrap_fiber_cut_eval, METH_VARARGS, NULL},
	 { (char *)"fwrap_create", _wrap_fwrap_create, METH_VARARGS, NULL},
	 { (char *)"fwrap_get_type", _wrap_fwrap_get_type, METH_VARARGS, NULL},
	 { (char *)"fwrap_set_f", _wrap_fwrap_set_f, METH_VARARGS, NULL},
	 { (char *)"fwrap_set_findex", _wrap_fwrap_set_findex, METH_VARARGS, NULL},
	 { (char *)"fwrap_set_fvec", _wrap_fwrap_set_fvec, METH_VARARGS, NULL},
	 { (char *)"fwrap_set_mofvec", _wrap_fwrap_set_mofvec, METH_VARARGS, NULL},
	 { (char *)"fwrap_set_which_eval", _wrap_fwrap_set_which_eval, METH_VARARGS, NULL},
	 { (char *)"fwrap_get_which_eval", _wrap_fwrap_get_which_eval, METH_VARARGS, NULL},
	 { (char *)"fwrap_set_num_funcs", _wrap_fwrap_set_num_funcs, METH_VARARGS, NULL},
	 { (char *)"fwrap_set_func_array", _wrap_fwrap_set_func_array, METH_VARARGS, NULL},
	 { (char *)"fwrap_destroy", _wrap_fwrap_destroy, METH_VARARGS, NULL},
	 { (char *)"fwrap_eval", _wrap_fwrap_eval, METH_VARARGS, NULL},
	 { (char *)"fwrap_initialize_fiber_approx", _wrap_fwrap_initialize_fiber_approx, METH_VARARGS, NULL},
	 { (char *)"fwrap_add_fiber", _wrap_fwrap_add_fiber, METH_VARARGS, NULL},
	 { (char *)"fwrap_set_which_fiber", _wrap_fwrap_set_which_fiber, METH_VARARGS, NULL},
	 { (char *)"fwrap_clean_fiber_approx", _wrap_fwrap_clean_fiber_approx, METH_VARARGS, NULL},
	 { (char *)"fwrap_eval_fiber", _wrap_fwrap_eval_fiber, METH_VARARGS, NULL},
	 { (char *)"init_hermite_poly", _wrap_init_hermite_poly, METH_VARARGS, NULL},
	 { (char *)"hermite_integrate", _wrap_hermite_integrate, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_aopts_alloc_adapt", _wrap_lin_elem_exp_aopts_alloc_adapt, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_aopts_free", _wrap_lin_elem_exp_aopts_free, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_aopts_free_deep", _wrap_lin_elem_exp_aopts_free_deep, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_aopts_get_lb", _wrap_lin_elem_exp_aopts_get_lb, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_aopts_get_ub", _wrap_lin_elem_exp_aopts_get_ub, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_aopts_set_nodes", _wrap_lin_elem_exp_aopts_set_nodes, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_aopts_set_nodes_copy", _wrap_lin_elem_exp_aopts_set_nodes_copy, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_aopts_set_adapt", _wrap_lin_elem_exp_aopts_set_adapt, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_aopts_set_delta", _wrap_lin_elem_exp_aopts_set_delta, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_aopts_set_hmin", _wrap_lin_elem_exp_aopts_set_hmin, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_aopts_get_num_nodes", _wrap_lin_elem_exp_aopts_get_num_nodes, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_aopts_get_nparams", _wrap_lin_elem_exp_aopts_get_nparams, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_aopts_set_nparams", _wrap_lin_elem_exp_aopts_set_nparams, METH_VARARGS, NULL},
	 { (char *)"LinElemExp_num_nodes_set", _wrap_LinElemExp_num_nodes_set, METH_VARARGS, NULL},
	 { (char *)"LinElemExp_num_nodes_get", _wrap_LinElemExp_num_nodes_get, METH_VARARGS, NULL},
	 { (char *)"LinElemExp_nodes_set", _wrap_LinElemExp_nodes_set, METH_VARARGS, NULL},
	 { (char *)"LinElemExp_nodes_get", _wrap_LinElemExp_nodes_get, METH_VARARGS, NULL},
	 { (char *)"LinElemExp_coeff_set", _wrap_LinElemExp_coeff_set, METH_VARARGS, NULL},
	 { (char *)"LinElemExp_coeff_get", _wrap_LinElemExp_coeff_get, METH_VARARGS, NULL},
	 { (char *)"LinElemExp_diff_set", _wrap_LinElemExp_diff_set, METH_VARARGS, NULL},
	 { (char *)"LinElemExp_diff_get", _wrap_LinElemExp_diff_get, METH_VARARGS, NULL},
	 { (char *)"LinElemExp_inner_set", _wrap_LinElemExp_inner_set, METH_VARARGS, NULL},
	 { (char *)"LinElemExp_inner_get", _wrap_LinElemExp_inner_get, METH_VARARGS, NULL},
	 { (char *)"LinElemExp_Lp_set", _wrap_LinElemExp_Lp_set, METH_VARARGS, NULL},
	 { (char *)"LinElemExp_Lp_get", _wrap_LinElemExp_Lp_get, METH_VARARGS, NULL},
	 { (char *)"new_LinElemExp", _wrap_new_LinElemExp, METH_VARARGS, NULL},
	 { (char *)"delete_LinElemExp", _wrap_delete_LinElemExp, METH_VARARGS, NULL},
	 { (char *)"LinElemExp_swigregister", LinElemExp_swigregister, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_get_num_nodes", _wrap_lin_elem_exp_get_num_nodes, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_get_num_params", _wrap_lin_elem_exp_get_num_params, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_alloc", _wrap_lin_elem_exp_alloc, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_copy", _wrap_lin_elem_exp_copy, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_free", _wrap_lin_elem_exp_free, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_init", _wrap_lin_elem_exp_init, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_create_with_params", _wrap_lin_elem_exp_create_with_params, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_update_params", _wrap_lin_elem_exp_update_params, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_get_params", _wrap_lin_elem_exp_get_params, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_get_params_ref", _wrap_lin_elem_exp_get_params_ref, METH_VARARGS, NULL},
	 { (char *)"serialize_lin_elem_exp", _wrap_serialize_lin_elem_exp, METH_VARARGS, NULL},
	 { (char *)"deserialize_lin_elem_exp", _wrap_deserialize_lin_elem_exp, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_eval", _wrap_lin_elem_exp_eval, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_deriv_eval", _wrap_lin_elem_exp_deriv_eval, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_evalN", _wrap_lin_elem_exp_evalN, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_get_nodal_val", _wrap_lin_elem_exp_get_nodal_val, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_deriv", _wrap_lin_elem_exp_deriv, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_dderiv", _wrap_lin_elem_exp_dderiv, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_dderiv_periodic", _wrap_lin_elem_exp_dderiv_periodic, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_param_grad_eval", _wrap_lin_elem_exp_param_grad_eval, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_param_grad_eval2", _wrap_lin_elem_exp_param_grad_eval2, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_squared_norm_param_grad", _wrap_lin_elem_exp_squared_norm_param_grad, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_integrate", _wrap_lin_elem_exp_integrate, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_integrate_weighted", _wrap_lin_elem_exp_integrate_weighted, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_inner", _wrap_lin_elem_exp_inner, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_axpy", _wrap_lin_elem_exp_axpy, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_prod", _wrap_lin_elem_exp_prod, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_norm", _wrap_lin_elem_exp_norm, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_max", _wrap_lin_elem_exp_max, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_min", _wrap_lin_elem_exp_min, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_absmax", _wrap_lin_elem_exp_absmax, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_err_est", _wrap_lin_elem_exp_err_est, METH_VARARGS, NULL},
	 { (char *)"lin_elem_adapt", _wrap_lin_elem_adapt, METH_VARARGS, NULL},
	 { (char *)"lin_elem_xy_get_x", _wrap_lin_elem_xy_get_x, METH_VARARGS, NULL},
	 { (char *)"lin_elem_xy_get_y", _wrap_lin_elem_xy_get_y, METH_VARARGS, NULL},
	 { (char *)"lin_elem_xy_next", _wrap_lin_elem_xy_next, METH_VARARGS, NULL},
	 { (char *)"lin_elem_xy_free", _wrap_lin_elem_xy_free, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_approx", _wrap_lin_elem_exp_approx, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_scale", _wrap_lin_elem_exp_scale, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_flip_sign", _wrap_lin_elem_exp_flip_sign, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_orth_basis", _wrap_lin_elem_exp_orth_basis, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_zero", _wrap_lin_elem_exp_zero, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_constant", _wrap_lin_elem_exp_constant, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_linear", _wrap_lin_elem_exp_linear, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_linear_update", _wrap_lin_elem_exp_linear_update, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_quadratic", _wrap_lin_elem_exp_quadratic, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_get_lb", _wrap_lin_elem_exp_get_lb, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_get_ub", _wrap_lin_elem_exp_get_ub, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_onezero", _wrap_lin_elem_exp_onezero, METH_VARARGS, NULL},
	 { (char *)"print_lin_elem_exp", _wrap_print_lin_elem_exp, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_savetxt", _wrap_lin_elem_exp_savetxt, METH_VARARGS, NULL},
	 { (char *)"lin_elem_exp_loadtxt", _wrap_lin_elem_exp_loadtxt, METH_VARARGS, NULL},
	 { (char *)"gauss_kernel_eval", _wrap_gauss_kernel_eval, METH_VARARGS, NULL},
	 { (char *)"gauss_kernel_deriv", _wrap_gauss_kernel_deriv, METH_VARARGS, NULL},
	 { (char *)"gauss_kernel_integrate", _wrap_gauss_kernel_integrate, METH_VARARGS, NULL},
	 { (char *)"gauss_kernel_inner", _wrap_gauss_kernel_inner, METH_VARARGS, NULL},
	 { (char *)"kernel_gaussian", _wrap_kernel_gaussian, METH_VARARGS, NULL},
	 { (char *)"kernel_free", _wrap_kernel_free, METH_VARARGS, NULL},
	 { (char *)"kernel_approx_opts_free", _wrap_kernel_approx_opts_free, METH_VARARGS, NULL},
	 { (char *)"kernel_approx_opts_gauss", _wrap_kernel_approx_opts_gauss, METH_VARARGS, NULL},
	 { (char *)"kernel_approx_opts_set_center_adapt", _wrap_kernel_approx_opts_set_center_adapt, METH_VARARGS, NULL},
	 { (char *)"kernel_approx_opts_linear_p", _wrap_kernel_approx_opts_linear_p, METH_VARARGS, NULL},
	 { (char *)"kernel_approx_opts_get_nparams", _wrap_kernel_approx_opts_get_nparams, METH_VARARGS, NULL},
	 { (char *)"kernel_approx_opts_set_nparams", _wrap_kernel_approx_opts_set_nparams, METH_VARARGS, NULL},
	 { (char *)"kernel_approx_opts_set_lb", _wrap_kernel_approx_opts_set_lb, METH_VARARGS, NULL},
	 { (char *)"kernel_approx_opts_get_lb", _wrap_kernel_approx_opts_get_lb, METH_VARARGS, NULL},
	 { (char *)"kernel_approx_opts_set_ub", _wrap_kernel_approx_opts_set_ub, METH_VARARGS, NULL},
	 { (char *)"kernel_approx_opts_get_ub", _wrap_kernel_approx_opts_get_ub, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_alloc", _wrap_kernel_expansion_alloc, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_get_lb", _wrap_kernel_expansion_get_lb, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_get_ub", _wrap_kernel_expansion_get_ub, METH_VARARGS, NULL},
	 { (char *)"serialize_kernel_expansion", _wrap_serialize_kernel_expansion, METH_VARARGS, NULL},
	 { (char *)"deserialize_kernel_expansion", _wrap_deserialize_kernel_expansion, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_copy", _wrap_kernel_expansion_copy, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_free", _wrap_kernel_expansion_free, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_set_bounds", _wrap_kernel_expansion_set_bounds, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_get_nkernels", _wrap_kernel_expansion_get_nkernels, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_add_kernel", _wrap_kernel_expansion_add_kernel, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_init", _wrap_kernel_expansion_init, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_update_params", _wrap_kernel_expansion_update_params, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_create_with_params", _wrap_kernel_expansion_create_with_params, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_zero", _wrap_kernel_expansion_zero, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_constant", _wrap_kernel_expansion_constant, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_linear", _wrap_kernel_expansion_linear, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_linear_update", _wrap_kernel_expansion_linear_update, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_quadratic", _wrap_kernel_expansion_quadratic, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_eval", _wrap_kernel_expansion_eval, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_evalN", _wrap_kernel_expansion_evalN, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_deriv", _wrap_kernel_expansion_deriv, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_dderiv", _wrap_kernel_expansion_dderiv, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_dderiv_periodic", _wrap_kernel_expansion_dderiv_periodic, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_deriv_eval", _wrap_kernel_expansion_deriv_eval, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_axpy", _wrap_kernel_expansion_axpy, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_integrate", _wrap_kernel_expansion_integrate, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_integrate_weighted", _wrap_kernel_expansion_integrate_weighted, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_prod", _wrap_kernel_expansion_prod, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_inner", _wrap_kernel_expansion_inner, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_scale", _wrap_kernel_expansion_scale, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_flip_sign", _wrap_kernel_expansion_flip_sign, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_get_num_params", _wrap_kernel_expansion_get_num_params, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_get_params", _wrap_kernel_expansion_get_params, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_get_params_ref", _wrap_kernel_expansion_get_params_ref, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_orth_basis", _wrap_kernel_expansion_orth_basis, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_param_grad_eval", _wrap_kernel_expansion_param_grad_eval, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_param_grad_eval2", _wrap_kernel_expansion_param_grad_eval2, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_squared_norm_param_grad", _wrap_kernel_expansion_squared_norm_param_grad, METH_VARARGS, NULL},
	 { (char *)"print_kernel_expansion", _wrap_print_kernel_expansion, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_absmax", _wrap_kernel_expansion_absmax, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_savetxt", _wrap_kernel_expansion_savetxt, METH_VARARGS, NULL},
	 { (char *)"kernel_expansion_loadtxt", _wrap_kernel_expansion_loadtxt, METH_VARARGS, NULL},
	 { (char *)"FunctionMonitor_f_set", _wrap_FunctionMonitor_f_set, METH_VARARGS, NULL},
	 { (char *)"FunctionMonitor_f_get", _wrap_FunctionMonitor_f_get, METH_VARARGS, NULL},
	 { (char *)"FunctionMonitor_ftype_set", _wrap_FunctionMonitor_ftype_set, METH_VARARGS, NULL},
	 { (char *)"FunctionMonitor_ftype_get", _wrap_FunctionMonitor_ftype_get, METH_VARARGS, NULL},
	 { (char *)"FunctionMonitor_dim_set", _wrap_FunctionMonitor_dim_set, METH_VARARGS, NULL},
	 { (char *)"FunctionMonitor_dim_get", _wrap_FunctionMonitor_dim_get, METH_VARARGS, NULL},
	 { (char *)"FunctionMonitor_args_set", _wrap_FunctionMonitor_args_set, METH_VARARGS, NULL},
	 { (char *)"FunctionMonitor_args_get", _wrap_FunctionMonitor_args_get, METH_VARARGS, NULL},
	 { (char *)"FunctionMonitor_evals_set", _wrap_FunctionMonitor_evals_set, METH_VARARGS, NULL},
	 { (char *)"FunctionMonitor_evals_get", _wrap_FunctionMonitor_evals_get, METH_VARARGS, NULL},
	 { (char *)"new_FunctionMonitor", _wrap_new_FunctionMonitor, METH_VARARGS, NULL},
	 { (char *)"delete_FunctionMonitor", _wrap_delete_FunctionMonitor, METH_VARARGS, NULL},
	 { (char *)"FunctionMonitor_swigregister", FunctionMonitor_swigregister, METH_VARARGS, NULL},
	 { (char *)"ff_fnd_set", _wrap_ff_fnd_set, METH_VARARGS, NULL},
	 { (char *)"ff_fnd_get", _wrap_ff_fnd_get, METH_VARARGS, NULL},
	 { (char *)"ff_f1d_set", _wrap_ff_f1d_set, METH_VARARGS, NULL},
	 { (char *)"ff_f1d_get", _wrap_ff_f1d_get, METH_VARARGS, NULL},
	 { (char *)"ff_f2d_set", _wrap_ff_f2d_set, METH_VARARGS, NULL},
	 { (char *)"ff_f2d_get", _wrap_ff_f2d_get, METH_VARARGS, NULL},
	 { (char *)"new_ff", _wrap_new_ff, METH_VARARGS, NULL},
	 { (char *)"delete_ff", _wrap_delete_ff, METH_VARARGS, NULL},
	 { (char *)"ff_swigregister", ff_swigregister, METH_VARARGS, NULL},
	 { (char *)"function_monitor_initnd", _wrap_function_monitor_initnd, METH_VARARGS, NULL},
	 { (char *)"function_monitor_free", _wrap_function_monitor_free, METH_VARARGS, NULL},
	 { (char *)"function_monitor_eval", _wrap_function_monitor_eval, METH_VARARGS, NULL},
	 { (char *)"function_monitor_print_to_file", _wrap_function_monitor_print_to_file, METH_VARARGS, NULL},
	 { (char *)"storevals_main_nEvals_set", _wrap_storevals_main_nEvals_set, METH_VARARGS, NULL},
	 { (char *)"storevals_main_nEvals_get", _wrap_storevals_main_nEvals_get, METH_VARARGS, NULL},
	 { (char *)"storevals_main_head_set", _wrap_storevals_main_head_set, METH_VARARGS, NULL},
	 { (char *)"storevals_main_head_get", _wrap_storevals_main_head_get, METH_VARARGS, NULL},
	 { (char *)"new_storevals_main", _wrap_new_storevals_main, METH_VARARGS, NULL},
	 { (char *)"delete_storevals_main", _wrap_delete_storevals_main, METH_VARARGS, NULL},
	 { (char *)"storevals_main_swigregister", storevals_main_swigregister, METH_VARARGS, NULL},
	 { (char *)"storevals_dim_set", _wrap_storevals_dim_set, METH_VARARGS, NULL},
	 { (char *)"storevals_dim_get", _wrap_storevals_dim_get, METH_VARARGS, NULL},
	 { (char *)"storevals_x_set", _wrap_storevals_x_set, METH_VARARGS, NULL},
	 { (char *)"storevals_x_get", _wrap_storevals_x_get, METH_VARARGS, NULL},
	 { (char *)"storevals_f_set", _wrap_storevals_f_set, METH_VARARGS, NULL},
	 { (char *)"storevals_f_get", _wrap_storevals_f_get, METH_VARARGS, NULL},
	 { (char *)"storevals_next_set", _wrap_storevals_next_set, METH_VARARGS, NULL},
	 { (char *)"storevals_next_get", _wrap_storevals_next_get, METH_VARARGS, NULL},
	 { (char *)"new_storevals", _wrap_new_storevals, METH_VARARGS, NULL},
	 { (char *)"delete_storevals", _wrap_delete_storevals, METH_VARARGS, NULL},
	 { (char *)"storevals_swigregister", storevals_swigregister, METH_VARARGS, NULL},
	 { (char *)"PushVal", _wrap_PushVal, METH_VARARGS, NULL},
	 { (char *)"PrintVals2d", _wrap_PrintVals2d, METH_VARARGS, NULL},
	 { (char *)"DeleteStoredVals", _wrap_DeleteStoredVals, METH_VARARGS, NULL},
	 { (char *)"Cpair_a_set", _wrap_Cpair_a_set, METH_VARARGS, NULL},
	 { (char *)"Cpair_a_get", _wrap_Cpair_a_get, METH_VARARGS, NULL},
	 { (char *)"Cpair_b_set", _wrap_Cpair_b_set, METH_VARARGS, NULL},
	 { (char *)"Cpair_b_get", _wrap_Cpair_b_get, METH_VARARGS, NULL},
	 { (char *)"new_Cpair", _wrap_new_Cpair, METH_VARARGS, NULL},
	 { (char *)"delete_Cpair", _wrap_delete_Cpair, METH_VARARGS, NULL},
	 { (char *)"Cpair_swigregister", Cpair_swigregister, METH_VARARGS, NULL},
	 { (char *)"cpair_create", _wrap_cpair_create, METH_VARARGS, NULL},
	 { (char *)"copy_cpair", _wrap_copy_cpair, METH_VARARGS, NULL},
	 { (char *)"print_cpair", _wrap_print_cpair, METH_VARARGS, NULL},
	 { (char *)"cpair_free", _wrap_cpair_free, METH_VARARGS, NULL},
	 { (char *)"cpair_isequal", _wrap_cpair_isequal, METH_VARARGS, NULL},
	 { (char *)"PairList_data_set", _wrap_PairList_data_set, METH_VARARGS, NULL},
	 { (char *)"PairList_data_get", _wrap_PairList_data_get, METH_VARARGS, NULL},
	 { (char *)"PairList_next_set", _wrap_PairList_next_set, METH_VARARGS, NULL},
	 { (char *)"PairList_next_get", _wrap_PairList_next_get, METH_VARARGS, NULL},
	 { (char *)"new_PairList", _wrap_new_PairList, METH_VARARGS, NULL},
	 { (char *)"delete_PairList", _wrap_delete_PairList, METH_VARARGS, NULL},
	 { (char *)"PairList_swigregister", PairList_swigregister, METH_VARARGS, NULL},
	 { (char *)"pair_push", _wrap_pair_push, METH_VARARGS, NULL},
	 { (char *)"print_pair_list", _wrap_print_pair_list, METH_VARARGS, NULL},
	 { (char *)"pair_list_delete", _wrap_pair_list_delete, METH_VARARGS, NULL},
	 { (char *)"pair_list_len", _wrap_pair_list_len, METH_VARARGS, NULL},
	 { (char *)"pair_list_index", _wrap_pair_list_index, METH_VARARGS, NULL},
	 { (char *)"HashtableCpair_size_set", _wrap_HashtableCpair_size_set, METH_VARARGS, NULL},
	 { (char *)"HashtableCpair_size_get", _wrap_HashtableCpair_size_get, METH_VARARGS, NULL},
	 { (char *)"HashtableCpair_table_set", _wrap_HashtableCpair_table_set, METH_VARARGS, NULL},
	 { (char *)"HashtableCpair_table_get", _wrap_HashtableCpair_table_get, METH_VARARGS, NULL},
	 { (char *)"new_HashtableCpair", _wrap_new_HashtableCpair, METH_VARARGS, NULL},
	 { (char *)"delete_HashtableCpair", _wrap_delete_HashtableCpair, METH_VARARGS, NULL},
	 { (char *)"HashtableCpair_swigregister", HashtableCpair_swigregister, METH_VARARGS, NULL},
	 { (char *)"create_hashtable_cp", _wrap_create_hashtable_cp, METH_VARARGS, NULL},
	 { (char *)"lookup_key", _wrap_lookup_key, METH_VARARGS, NULL},
	 { (char *)"add_cpair", _wrap_add_cpair, METH_VARARGS, NULL},
	 { (char *)"free_hashtable_cp", _wrap_free_hashtable_cp, METH_VARARGS, NULL},
	 { (char *)"nstored_hashtable_cp", _wrap_nstored_hashtable_cp, METH_VARARGS, NULL},
	 { (char *)"hashsimple", _wrap_hashsimple, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_alloc", _wrap_pw_poly_opts_alloc, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_free", _wrap_pw_poly_opts_free, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_free_deep", _wrap_pw_poly_opts_free_deep, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_set_lb", _wrap_pw_poly_opts_set_lb, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_get_lb", _wrap_pw_poly_opts_get_lb, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_set_ub", _wrap_pw_poly_opts_set_ub, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_get_ub", _wrap_pw_poly_opts_get_ub, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_set_ptype", _wrap_pw_poly_opts_set_ptype, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_get_ptype", _wrap_pw_poly_opts_get_ptype, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_set_minsize", _wrap_pw_poly_opts_set_minsize, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_set_maxorder", _wrap_pw_poly_opts_set_maxorder, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_set_nregions", _wrap_pw_poly_opts_set_nregions, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_set_pts", _wrap_pw_poly_opts_set_pts, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_set_tol", _wrap_pw_poly_opts_set_tol, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_set_coeffs_check", _wrap_pw_poly_opts_set_coeffs_check, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_get_nparams", _wrap_pw_poly_opts_get_nparams, METH_VARARGS, NULL},
	 { (char *)"pw_poly_opts_set_nparams", _wrap_pw_poly_opts_set_nparams, METH_VARARGS, NULL},
	 { (char *)"PiecewisePoly_leaf_set", _wrap_PiecewisePoly_leaf_set, METH_VARARGS, NULL},
	 { (char *)"PiecewisePoly_leaf_get", _wrap_PiecewisePoly_leaf_get, METH_VARARGS, NULL},
	 { (char *)"PiecewisePoly_nbranches_set", _wrap_PiecewisePoly_nbranches_set, METH_VARARGS, NULL},
	 { (char *)"PiecewisePoly_nbranches_get", _wrap_PiecewisePoly_nbranches_get, METH_VARARGS, NULL},
	 { (char *)"PiecewisePoly_branches_set", _wrap_PiecewisePoly_branches_set, METH_VARARGS, NULL},
	 { (char *)"PiecewisePoly_branches_get", _wrap_PiecewisePoly_branches_get, METH_VARARGS, NULL},
	 { (char *)"PiecewisePoly_ope_set", _wrap_PiecewisePoly_ope_set, METH_VARARGS, NULL},
	 { (char *)"PiecewisePoly_ope_get", _wrap_PiecewisePoly_ope_get, METH_VARARGS, NULL},
	 { (char *)"new_PiecewisePoly", _wrap_new_PiecewisePoly, METH_VARARGS, NULL},
	 { (char *)"delete_PiecewisePoly", _wrap_delete_PiecewisePoly, METH_VARARGS, NULL},
	 { (char *)"PiecewisePoly_swigregister", PiecewisePoly_swigregister, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_alloc", _wrap_piecewise_poly_alloc, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_array_alloc", _wrap_piecewise_poly_array_alloc, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_copy", _wrap_piecewise_poly_copy, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_free", _wrap_piecewise_poly_free, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_array_free", _wrap_piecewise_poly_array_free, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_get_ptype", _wrap_piecewise_poly_get_ptype, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_genorder", _wrap_piecewise_poly_genorder, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_constant", _wrap_piecewise_poly_constant, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_zero", _wrap_piecewise_poly_zero, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_linear", _wrap_piecewise_poly_linear, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_linear_update", _wrap_piecewise_poly_linear_update, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_quadratic", _wrap_piecewise_poly_quadratic, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_splitn", _wrap_piecewise_poly_splitn, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_isflat", _wrap_piecewise_poly_isflat, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_get_lb", _wrap_piecewise_poly_get_lb, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_get_ub", _wrap_piecewise_poly_get_ub, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_nregions_base", _wrap_piecewise_poly_nregions_base, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_nregions", _wrap_piecewise_poly_nregions, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_boundaries", _wrap_piecewise_poly_boundaries, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_eval", _wrap_piecewise_poly_eval, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_deriv_eval", _wrap_piecewise_poly_deriv_eval, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_evalN", _wrap_piecewise_poly_evalN, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_scale", _wrap_piecewise_poly_scale, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_deriv", _wrap_piecewise_poly_deriv, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_dderiv", _wrap_piecewise_poly_dderiv, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_dderiv_periodic", _wrap_piecewise_poly_dderiv_periodic, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_integrate", _wrap_piecewise_poly_integrate, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_integrate_weighted", _wrap_piecewise_poly_integrate_weighted, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_real_roots", _wrap_piecewise_poly_real_roots, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_max", _wrap_piecewise_poly_max, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_min", _wrap_piecewise_poly_min, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_absmax", _wrap_piecewise_poly_absmax, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_norm", _wrap_piecewise_poly_norm, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_flip_sign", _wrap_piecewise_poly_flip_sign, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_copy_leaves", _wrap_piecewise_poly_copy_leaves, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_ref_leaves", _wrap_piecewise_poly_ref_leaves, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_flatten", _wrap_piecewise_poly_flatten, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_finer_grid", _wrap_piecewise_poly_finer_grid, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_match", _wrap_piecewise_poly_match, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_prod", _wrap_piecewise_poly_prod, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_inner", _wrap_piecewise_poly_inner, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_axpy", _wrap_piecewise_poly_axpy, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_daxpby", _wrap_piecewise_poly_daxpby, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_matched_daxpby", _wrap_piecewise_poly_matched_daxpby, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_matched_prod", _wrap_piecewise_poly_matched_prod, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_approx1", _wrap_piecewise_poly_approx1, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_approx1_adapt", _wrap_piecewise_poly_approx1_adapt, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_check_discontinuity", _wrap_piecewise_poly_check_discontinuity, METH_VARARGS, NULL},
	 { (char *)"minmod_eval", _wrap_minmod_eval, METH_VARARGS, NULL},
	 { (char *)"minmod_disc_exists", _wrap_minmod_disc_exists, METH_VARARGS, NULL},
	 { (char *)"locate_jumps", _wrap_locate_jumps, METH_VARARGS, NULL},
	 { (char *)"serialize_piecewise_poly", _wrap_serialize_piecewise_poly, METH_VARARGS, NULL},
	 { (char *)"deserialize_piecewise_poly", _wrap_deserialize_piecewise_poly, METH_VARARGS, NULL},
	 { (char *)"print_piecewise_poly", _wrap_print_piecewise_poly, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_savetxt", _wrap_piecewise_poly_savetxt, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_loadtxt", _wrap_piecewise_poly_loadtxt, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_get_num_params", _wrap_piecewise_poly_get_num_params, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_update_params", _wrap_piecewise_poly_update_params, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_param_grad_eval", _wrap_piecewise_poly_param_grad_eval, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_param_grad_eval2", _wrap_piecewise_poly_param_grad_eval2, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_squared_norm_param_grad", _wrap_piecewise_poly_squared_norm_param_grad, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_get_params", _wrap_piecewise_poly_get_params, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_get_params_ref", _wrap_piecewise_poly_get_params_ref, METH_VARARGS, NULL},
	 { (char *)"piecewise_poly_create_with_params", _wrap_piecewise_poly_create_with_params, METH_VARARGS, NULL},
	 { (char *)"pivot_get_size", _wrap_pivot_get_size, METH_VARARGS, NULL},
	 { (char *)"pivot_get_ind", _wrap_pivot_get_ind, METH_VARARGS, NULL},
	 { (char *)"pivot_get_loc", _wrap_pivot_get_loc, METH_VARARGS, NULL},
	 { (char *)"pivot_set_ind", _wrap_pivot_set_ind, METH_VARARGS, NULL},
	 { (char *)"pivot_set_get_pivot", _wrap_pivot_set_get_pivot, METH_VARARGS, NULL},
	 { (char *)"space_mapping_map", _wrap_space_mapping_map, METH_VARARGS, NULL},
	 { (char *)"space_mapping_map_inverse", _wrap_space_mapping_map_inverse, METH_VARARGS, NULL},
	 { (char *)"space_mapping_map_deriv", _wrap_space_mapping_map_deriv, METH_VARARGS, NULL},
	 { (char *)"space_mapping_map_inverse_deriv", _wrap_space_mapping_map_inverse_deriv, METH_VARARGS, NULL},
	 { (char *)"ope_opts_alloc", _wrap_ope_opts_alloc, METH_VARARGS, NULL},
	 { (char *)"ope_opts_free", _wrap_ope_opts_free, METH_VARARGS, NULL},
	 { (char *)"ope_opts_free_deep", _wrap_ope_opts_free_deep, METH_VARARGS, NULL},
	 { (char *)"ope_opts_set_start", _wrap_ope_opts_set_start, METH_VARARGS, NULL},
	 { (char *)"ope_opts_get_start", _wrap_ope_opts_get_start, METH_VARARGS, NULL},
	 { (char *)"ope_opts_set_maxnum", _wrap_ope_opts_set_maxnum, METH_VARARGS, NULL},
	 { (char *)"ope_opts_get_maxnum", _wrap_ope_opts_get_maxnum, METH_VARARGS, NULL},
	 { (char *)"ope_opts_set_coeffs_check", _wrap_ope_opts_set_coeffs_check, METH_VARARGS, NULL},
	 { (char *)"ope_opts_set_tol", _wrap_ope_opts_set_tol, METH_VARARGS, NULL},
	 { (char *)"ope_opts_set_lb", _wrap_ope_opts_set_lb, METH_VARARGS, NULL},
	 { (char *)"ope_opts_get_lb", _wrap_ope_opts_get_lb, METH_VARARGS, NULL},
	 { (char *)"ope_opts_set_ub", _wrap_ope_opts_set_ub, METH_VARARGS, NULL},
	 { (char *)"ope_opts_get_ub", _wrap_ope_opts_get_ub, METH_VARARGS, NULL},
	 { (char *)"ope_opts_set_mean_and_std", _wrap_ope_opts_set_mean_and_std, METH_VARARGS, NULL},
	 { (char *)"ope_opts_set_ptype", _wrap_ope_opts_set_ptype, METH_VARARGS, NULL},
	 { (char *)"ope_opts_get_ptype", _wrap_ope_opts_get_ptype, METH_VARARGS, NULL},
	 { (char *)"ope_opts_set_qrule", _wrap_ope_opts_set_qrule, METH_VARARGS, NULL},
	 { (char *)"ope_opts_get_nparams", _wrap_ope_opts_get_nparams, METH_VARARGS, NULL},
	 { (char *)"ope_opts_set_nparams", _wrap_ope_opts_set_nparams, METH_VARARGS, NULL},
	 { (char *)"ope_opts_set_kristoffel_weight", _wrap_ope_opts_set_kristoffel_weight, METH_VARARGS, NULL},
	 { (char *)"StandardPoly_ptype_set", _wrap_StandardPoly_ptype_set, METH_VARARGS, NULL},
	 { (char *)"StandardPoly_ptype_get", _wrap_StandardPoly_ptype_get, METH_VARARGS, NULL},
	 { (char *)"StandardPoly_num_poly_set", _wrap_StandardPoly_num_poly_set, METH_VARARGS, NULL},
	 { (char *)"StandardPoly_num_poly_get", _wrap_StandardPoly_num_poly_get, METH_VARARGS, NULL},
	 { (char *)"StandardPoly_lower_bound_set", _wrap_StandardPoly_lower_bound_set, METH_VARARGS, NULL},
	 { (char *)"StandardPoly_lower_bound_get", _wrap_StandardPoly_lower_bound_get, METH_VARARGS, NULL},
	 { (char *)"StandardPoly_upper_bound_set", _wrap_StandardPoly_upper_bound_set, METH_VARARGS, NULL},
	 { (char *)"StandardPoly_upper_bound_get", _wrap_StandardPoly_upper_bound_get, METH_VARARGS, NULL},
	 { (char *)"StandardPoly_coeff_set", _wrap_StandardPoly_coeff_set, METH_VARARGS, NULL},
	 { (char *)"StandardPoly_coeff_get", _wrap_StandardPoly_coeff_get, METH_VARARGS, NULL},
	 { (char *)"new_StandardPoly", _wrap_new_StandardPoly, METH_VARARGS, NULL},
	 { (char *)"delete_StandardPoly", _wrap_delete_StandardPoly, METH_VARARGS, NULL},
	 { (char *)"StandardPoly_swigregister", StandardPoly_swigregister, METH_VARARGS, NULL},
	 { (char *)"standard_poly_init", _wrap_standard_poly_init, METH_VARARGS, NULL},
	 { (char *)"standard_poly_deriv", _wrap_standard_poly_deriv, METH_VARARGS, NULL},
	 { (char *)"standard_poly_free", _wrap_standard_poly_free, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_ptype_set", _wrap_OrthPoly_ptype_set, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_ptype_get", _wrap_OrthPoly_ptype_get, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_an_set", _wrap_OrthPoly_an_set, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_an_get", _wrap_OrthPoly_an_get, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_bn_set", _wrap_OrthPoly_bn_set, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_bn_get", _wrap_OrthPoly_bn_get, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_cn_set", _wrap_OrthPoly_cn_set, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_cn_get", _wrap_OrthPoly_cn_get, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_lower_set", _wrap_OrthPoly_lower_set, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_lower_get", _wrap_OrthPoly_lower_get, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_upper_set", _wrap_OrthPoly_upper_set, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_upper_get", _wrap_OrthPoly_upper_get, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_const_term_set", _wrap_OrthPoly_const_term_set, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_const_term_get", _wrap_OrthPoly_const_term_get, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_lin_coeff_set", _wrap_OrthPoly_lin_coeff_set, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_lin_coeff_get", _wrap_OrthPoly_lin_coeff_get, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_lin_const_set", _wrap_OrthPoly_lin_const_set, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_lin_const_get", _wrap_OrthPoly_lin_const_get, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_norm_set", _wrap_OrthPoly_norm_set, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_norm_get", _wrap_OrthPoly_norm_get, METH_VARARGS, NULL},
	 { (char *)"new_OrthPoly", _wrap_new_OrthPoly, METH_VARARGS, NULL},
	 { (char *)"delete_OrthPoly", _wrap_delete_OrthPoly, METH_VARARGS, NULL},
	 { (char *)"OrthPoly_swigregister", OrthPoly_swigregister, METH_VARARGS, NULL},
	 { (char *)"init_cheb_poly", _wrap_init_cheb_poly, METH_VARARGS, NULL},
	 { (char *)"init_leg_poly", _wrap_init_leg_poly, METH_VARARGS, NULL},
	 { (char *)"free_orth_poly", _wrap_free_orth_poly, METH_VARARGS, NULL},
	 { (char *)"serialize_orth_poly", _wrap_serialize_orth_poly, METH_VARARGS, NULL},
	 { (char *)"deserialize_orth_poly", _wrap_deserialize_orth_poly, METH_VARARGS, NULL},
	 { (char *)"orth_to_standard_poly", _wrap_orth_to_standard_poly, METH_VARARGS, NULL},
	 { (char *)"deriv_legen", _wrap_deriv_legen, METH_VARARGS, NULL},
	 { (char *)"deriv_legen_upto", _wrap_deriv_legen_upto, METH_VARARGS, NULL},
	 { (char *)"orth_poly_eval", _wrap_orth_poly_eval, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_p_set", _wrap_OrthPolyExpansion_p_set, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_p_get", _wrap_OrthPolyExpansion_p_get, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_num_poly_set", _wrap_OrthPolyExpansion_num_poly_set, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_num_poly_get", _wrap_OrthPolyExpansion_num_poly_get, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_lower_bound_set", _wrap_OrthPolyExpansion_lower_bound_set, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_lower_bound_get", _wrap_OrthPolyExpansion_lower_bound_get, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_upper_bound_set", _wrap_OrthPolyExpansion_upper_bound_set, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_upper_bound_get", _wrap_OrthPolyExpansion_upper_bound_get, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_coeff_set", _wrap_OrthPolyExpansion_coeff_set, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_coeff_get", _wrap_OrthPolyExpansion_coeff_get, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_ccoeff_set", _wrap_OrthPolyExpansion_ccoeff_set, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_ccoeff_get", _wrap_OrthPolyExpansion_ccoeff_get, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_nalloc_set", _wrap_OrthPolyExpansion_nalloc_set, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_nalloc_get", _wrap_OrthPolyExpansion_nalloc_get, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_space_transform_set", _wrap_OrthPolyExpansion_space_transform_set, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_space_transform_get", _wrap_OrthPolyExpansion_space_transform_get, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_kristoffel_eval_set", _wrap_OrthPolyExpansion_kristoffel_eval_set, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_kristoffel_eval_get", _wrap_OrthPolyExpansion_kristoffel_eval_get, METH_VARARGS, NULL},
	 { (char *)"new_OrthPolyExpansion", _wrap_new_OrthPolyExpansion, METH_VARARGS, NULL},
	 { (char *)"delete_OrthPolyExpansion", _wrap_delete_OrthPolyExpansion, METH_VARARGS, NULL},
	 { (char *)"OrthPolyExpansion_swigregister", OrthPolyExpansion_swigregister, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_get_num_poly", _wrap_orth_poly_expansion_get_num_poly, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_get_num_params", _wrap_orth_poly_expansion_get_num_params, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_get_lb", _wrap_orth_poly_expansion_get_lb, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_get_ub", _wrap_orth_poly_expansion_get_ub, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_init", _wrap_orth_poly_expansion_init, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_init_from_opts", _wrap_orth_poly_expansion_init_from_opts, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_create_with_params", _wrap_orth_poly_expansion_create_with_params, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_get_params", _wrap_orth_poly_expansion_get_params, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_get_params_ref", _wrap_orth_poly_expansion_get_params_ref, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_update_params", _wrap_orth_poly_expansion_update_params, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_copy", _wrap_orth_poly_expansion_copy, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_get_ptype", _wrap_orth_poly_expansion_get_ptype, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_zero", _wrap_orth_poly_expansion_zero, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_constant", _wrap_orth_poly_expansion_constant, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_linear", _wrap_orth_poly_expansion_linear, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_linear_update", _wrap_orth_poly_expansion_linear_update, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_quadratic", _wrap_orth_poly_expansion_quadratic, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_genorder", _wrap_orth_poly_expansion_genorder, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_orth_basis", _wrap_orth_poly_expansion_orth_basis, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_deriv_eval", _wrap_orth_poly_expansion_deriv_eval, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_deriv", _wrap_orth_poly_expansion_deriv, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_dderiv", _wrap_orth_poly_expansion_dderiv, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_dderiv_periodic", _wrap_orth_poly_expansion_dderiv_periodic, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_free", _wrap_orth_poly_expansion_free, METH_VARARGS, NULL},
	 { (char *)"serialize_orth_poly_expansion", _wrap_serialize_orth_poly_expansion, METH_VARARGS, NULL},
	 { (char *)"deserialize_orth_poly_expansion", _wrap_deserialize_orth_poly_expansion, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_savetxt", _wrap_orth_poly_expansion_savetxt, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_loadtxt", _wrap_orth_poly_expansion_loadtxt, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_to_standard_poly", _wrap_orth_poly_expansion_to_standard_poly, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_arr_eval", _wrap_orth_poly_expansion_arr_eval, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_arr_evalN", _wrap_orth_poly_expansion_arr_evalN, METH_VARARGS, NULL},
	 { (char *)"chebyshev_poly_expansion_eval", _wrap_chebyshev_poly_expansion_eval, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_eval", _wrap_orth_poly_expansion_eval, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_get_kristoffel_weight", _wrap_orth_poly_expansion_get_kristoffel_weight, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_evalN", _wrap_orth_poly_expansion_evalN, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_param_grad_eval", _wrap_orth_poly_expansion_param_grad_eval, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_param_grad_eval2", _wrap_orth_poly_expansion_param_grad_eval2, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_squared_norm_param_grad", _wrap_orth_poly_expansion_squared_norm_param_grad, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_rkhs_squared_norm", _wrap_orth_poly_expansion_rkhs_squared_norm, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_rkhs_squared_norm_param_grad", _wrap_orth_poly_expansion_rkhs_squared_norm_param_grad, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_round", _wrap_orth_poly_expansion_round, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_roundt", _wrap_orth_poly_expansion_roundt, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_approx", _wrap_orth_poly_expansion_approx, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_approx_vec", _wrap_orth_poly_expansion_approx_vec, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_approx_adapt", _wrap_orth_poly_expansion_approx_adapt, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_randu", _wrap_orth_poly_expansion_randu, METH_VARARGS, NULL},
	 { (char *)"cheb_integrate2", _wrap_cheb_integrate2, METH_VARARGS, NULL},
	 { (char *)"legendre_integrate", _wrap_legendre_integrate, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_prod", _wrap_orth_poly_expansion_prod, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_sum_prod", _wrap_orth_poly_expansion_sum_prod, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_integrate", _wrap_orth_poly_expansion_integrate, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_integrate_weighted", _wrap_orth_poly_expansion_integrate_weighted, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_inner_w", _wrap_orth_poly_expansion_inner_w, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_inner", _wrap_orth_poly_expansion_inner, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_norm_w", _wrap_orth_poly_expansion_norm_w, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_norm", _wrap_orth_poly_expansion_norm, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_flip_sign", _wrap_orth_poly_expansion_flip_sign, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_scale", _wrap_orth_poly_expansion_scale, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_daxpby", _wrap_orth_poly_expansion_daxpby, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_axpy", _wrap_orth_poly_expansion_axpy, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_sum3_up", _wrap_orth_poly_expansion_sum3_up, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_lin_comb", _wrap_orth_poly_expansion_lin_comb, METH_VARARGS, NULL},
	 { (char *)"legendre_expansion_real_roots", _wrap_legendre_expansion_real_roots, METH_VARARGS, NULL},
	 { (char *)"standard_poly_real_roots", _wrap_standard_poly_real_roots, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_real_roots", _wrap_orth_poly_expansion_real_roots, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_max", _wrap_orth_poly_expansion_max, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_min", _wrap_orth_poly_expansion_min, METH_VARARGS, NULL},
	 { (char *)"orth_poly_expansion_absmax", _wrap_orth_poly_expansion_absmax, METH_VARARGS, NULL},
	 { (char *)"print_orth_poly_expansion", _wrap_print_orth_poly_expansion, METH_VARARGS, NULL},
	 { (char *)"bounding_box_init_std", _wrap_bounding_box_init_std, METH_VARARGS, NULL},
	 { (char *)"bounding_box_init", _wrap_bounding_box_init, METH_VARARGS, NULL},
	 { (char *)"bounding_box_vec", _wrap_bounding_box_vec, METH_VARARGS, NULL},
	 { (char *)"bounding_box_free", _wrap_bounding_box_free, METH_VARARGS, NULL},
	 { (char *)"bounding_box_get_dim", _wrap_bounding_box_get_dim, METH_VARARGS, NULL},
	 { (char *)"bounding_box_get_lb", _wrap_bounding_box_get_lb, METH_VARARGS, NULL},
	 { (char *)"bounding_box_get_ub", _wrap_bounding_box_get_ub, METH_VARARGS, NULL},
	 { (char *)"bounding_box_get_ub_dim", _wrap_bounding_box_get_ub_dim, METH_VARARGS, NULL},
	 { (char *)"bounding_box_set_ub_dim", _wrap_bounding_box_set_ub_dim, METH_VARARGS, NULL},
	 { (char *)"bounding_box_get_lb_dim", _wrap_bounding_box_get_lb_dim, METH_VARARGS, NULL},
	 { (char *)"bounding_box_set_lb_dim", _wrap_bounding_box_set_lb_dim, METH_VARARGS, NULL},
	 { (char *)"dgetri_", _wrap_dgetri_, METH_VARARGS, NULL},
	 { (char *)"dgetrf_", _wrap_dgetrf_, METH_VARARGS, NULL},
	 { (char *)"dorgqr_", _wrap_dorgqr_, METH_VARARGS, NULL},
	 { (char *)"dgeqrf_", _wrap_dgeqrf_, METH_VARARGS, NULL},
	 { (char *)"dgeev_", _wrap_dgeev_, METH_VARARGS, NULL},
	 { (char *)"dgebal_", _wrap_dgebal_, METH_VARARGS, NULL},
	 { (char *)"dhseqr_", _wrap_dhseqr_, METH_VARARGS, NULL},
	 { (char *)"dorgrq_", _wrap_dorgrq_, METH_VARARGS, NULL},
	 { (char *)"dgerqf_", _wrap_dgerqf_, METH_VARARGS, NULL},
	 { (char *)"dgesdd_", _wrap_dgesdd_, METH_VARARGS, NULL},
	 { (char *)"dstev_", _wrap_dstev_, METH_VARARGS, NULL},
	 { (char *)"dsyev_", _wrap_dsyev_, METH_VARARGS, NULL},
	 { (char *)"dpotrf_", _wrap_dpotrf_, METH_VARARGS, NULL},
	 { (char *)"dpotri_", _wrap_dpotri_, METH_VARARGS, NULL},
	 { (char *)"dtrtri_", _wrap_dtrtri_, METH_VARARGS, NULL},
	 { (char *)"dgesv_", _wrap_dgesv_, METH_VARARGS, NULL},
	 { (char *)"dgelsd_", _wrap_dgelsd_, METH_VARARGS, NULL},
	 { (char *)"c3linalg_multiple_vec_mat", _wrap_c3linalg_multiple_vec_mat, METH_VARARGS, NULL},
	 { (char *)"c3linalg_multiple_mat_vec", _wrap_c3linalg_multiple_mat_vec, METH_VARARGS, NULL},
	 { (char *)"qr", _wrap_qr, METH_VARARGS, NULL},
	 { (char *)"rq_with_rmult", _wrap_rq_with_rmult, METH_VARARGS, NULL},
	 { (char *)"svd", _wrap_svd, METH_VARARGS, NULL},
	 { (char *)"truncated_svd", _wrap_truncated_svd, METH_VARARGS, NULL},
	 { (char *)"pinv", _wrap_pinv, METH_VARARGS, NULL},
	 { (char *)"norm2", _wrap_norm2, METH_VARARGS, NULL},
	 { (char *)"norm2diff", _wrap_norm2diff, METH_VARARGS, NULL},
	 { (char *)"mean", _wrap_mean, METH_VARARGS, NULL},
	 { (char *)"mean_size_t", _wrap_mean_size_t, METH_VARARGS, NULL},
	 { (char *)"kron", _wrap_kron, METH_VARARGS, NULL},
	 { (char *)"kron_col", _wrap_kron_col, METH_VARARGS, NULL},
	 { (char *)"vec_kron", _wrap_vec_kron, METH_VARARGS, NULL},
	 { (char *)"vec_kronl", _wrap_vec_kronl, METH_VARARGS, NULL},
	 { (char *)"fiber_list_index_set", _wrap_fiber_list_index_set, METH_VARARGS, NULL},
	 { (char *)"fiber_list_index_get", _wrap_fiber_list_index_get, METH_VARARGS, NULL},
	 { (char *)"fiber_list_vals_set", _wrap_fiber_list_vals_set, METH_VARARGS, NULL},
	 { (char *)"fiber_list_vals_get", _wrap_fiber_list_vals_get, METH_VARARGS, NULL},
	 { (char *)"fiber_list_next_set", _wrap_fiber_list_next_set, METH_VARARGS, NULL},
	 { (char *)"fiber_list_next_get", _wrap_fiber_list_next_get, METH_VARARGS, NULL},
	 { (char *)"new_fiber_list", _wrap_new_fiber_list, METH_VARARGS, NULL},
	 { (char *)"delete_fiber_list", _wrap_delete_fiber_list, METH_VARARGS, NULL},
	 { (char *)"fiber_list_swigregister", fiber_list_swigregister, METH_VARARGS, NULL},
	 { (char *)"fiber_info_nfibers_set", _wrap_fiber_info_nfibers_set, METH_VARARGS, NULL},
	 { (char *)"fiber_info_nfibers_get", _wrap_fiber_info_nfibers_get, METH_VARARGS, NULL},
	 { (char *)"fiber_info_head_set", _wrap_fiber_info_head_set, METH_VARARGS, NULL},
	 { (char *)"fiber_info_head_get", _wrap_fiber_info_head_get, METH_VARARGS, NULL},
	 { (char *)"new_fiber_info", _wrap_new_fiber_info, METH_VARARGS, NULL},
	 { (char *)"delete_fiber_info", _wrap_delete_fiber_info, METH_VARARGS, NULL},
	 { (char *)"fiber_info_swigregister", fiber_info_swigregister, METH_VARARGS, NULL},
	 { (char *)"AddFiber", _wrap_AddFiber, METH_VARARGS, NULL},
	 { (char *)"IndexExists", _wrap_IndexExists, METH_VARARGS, NULL},
	 { (char *)"getIndex", _wrap_getIndex, METH_VARARGS, NULL},
	 { (char *)"DeleteFiberList", _wrap_DeleteFiberList, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_n_set", _wrap_sk_decomp_n_set, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_n_get", _wrap_sk_decomp_n_get, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_m_set", _wrap_sk_decomp_m_set, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_m_get", _wrap_sk_decomp_m_get, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_rank_set", _wrap_sk_decomp_rank_set, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_rank_get", _wrap_sk_decomp_rank_get, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_rows_kept_set", _wrap_sk_decomp_rows_kept_set, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_rows_kept_get", _wrap_sk_decomp_rows_kept_get, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_cols_kept_set", _wrap_sk_decomp_cols_kept_set, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_cols_kept_get", _wrap_sk_decomp_cols_kept_get, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_cross_rank_set", _wrap_sk_decomp_cross_rank_set, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_cross_rank_get", _wrap_sk_decomp_cross_rank_get, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_cross_inv_set", _wrap_sk_decomp_cross_inv_set, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_cross_inv_get", _wrap_sk_decomp_cross_inv_get, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_row_vals_set", _wrap_sk_decomp_row_vals_set, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_row_vals_get", _wrap_sk_decomp_row_vals_get, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_col_vals_set", _wrap_sk_decomp_col_vals_set, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_col_vals_get", _wrap_sk_decomp_col_vals_get, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_success_set", _wrap_sk_decomp_success_set, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_success_get", _wrap_sk_decomp_success_get, METH_VARARGS, NULL},
	 { (char *)"new_sk_decomp", _wrap_new_sk_decomp, METH_VARARGS, NULL},
	 { (char *)"delete_sk_decomp", _wrap_delete_sk_decomp, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_swigregister", sk_decomp_swigregister, METH_VARARGS, NULL},
	 { (char *)"init_skf", _wrap_init_skf, METH_VARARGS, NULL},
	 { (char *)"sk_decomp_to_full", _wrap_sk_decomp_to_full, METH_VARARGS, NULL},
	 { (char *)"free_skf", _wrap_free_skf, METH_VARARGS, NULL},
	 { (char *)"maxvol_rhs", _wrap_maxvol_rhs, METH_VARARGS, NULL},
	 { (char *)"skeleton", _wrap_skeleton, METH_VARARGS, NULL},
	 { (char *)"skeleton_func", _wrap_skeleton_func, METH_VARARGS, NULL},
	 { (char *)"skeleton_func2", _wrap_skeleton_func2, METH_VARARGS, NULL},
	 { (char *)"linear_ls", _wrap_linear_ls, METH_VARARGS, NULL},
	 { (char *)"mat_nrows_set", _wrap_mat_nrows_set, METH_VARARGS, NULL},
	 { (char *)"mat_nrows_get", _wrap_mat_nrows_get, METH_VARARGS, NULL},
	 { (char *)"mat_ncols_set", _wrap_mat_ncols_set, METH_VARARGS, NULL},
	 { (char *)"mat_ncols_get", _wrap_mat_ncols_get, METH_VARARGS, NULL},
	 { (char *)"mat_vals_set", _wrap_mat_vals_set, METH_VARARGS, NULL},
	 { (char *)"mat_vals_get", _wrap_mat_vals_get, METH_VARARGS, NULL},
	 { (char *)"new_mat", _wrap_new_mat, METH_VARARGS, NULL},
	 { (char *)"delete_mat", _wrap_delete_mat, METH_VARARGS, NULL},
	 { (char *)"mat_swigregister", mat_swigregister, METH_VARARGS, NULL},
	 { (char *)"v2m", _wrap_v2m, METH_VARARGS, NULL},
	 { (char *)"diagv2m", _wrap_diagv2m, METH_VARARGS, NULL},
	 { (char *)"horizcat", _wrap_horizcat, METH_VARARGS, NULL},
	 { (char *)"block_diag", _wrap_block_diag, METH_VARARGS, NULL},
	 { (char *)"freemat", _wrap_freemat, METH_VARARGS, NULL},
	 { (char *)"printmat", _wrap_printmat, METH_VARARGS, NULL},
	 { (char *)"mat_ones", _wrap_mat_ones, METH_VARARGS, NULL},
	 { (char *)"c3opt_create", _wrap_c3opt_create, METH_VARARGS, NULL},
	 { (char *)"c3opt_set_nvars", _wrap_c3opt_set_nvars, METH_VARARGS, NULL},
	 { (char *)"c3opt_alloc", _wrap_c3opt_alloc, METH_VARARGS, NULL},
	 { (char *)"c3opt_copy", _wrap_c3opt_copy, METH_VARARGS, NULL},
	 { (char *)"c3opt_free", _wrap_c3opt_free, METH_VARARGS, NULL},
	 { (char *)"c3opt_set_sgd_learn_rate", _wrap_c3opt_set_sgd_learn_rate, METH_VARARGS, NULL},
	 { (char *)"c3opt_set_sgd_nsamples", _wrap_c3opt_set_sgd_nsamples, METH_VARARGS, NULL},
	 { (char *)"c3opt_get_sgd_nsamples", _wrap_c3opt_get_sgd_nsamples, METH_VARARGS, NULL},
	 { (char *)"c3opt_set_nvectors_store", _wrap_c3opt_set_nvectors_store, METH_VARARGS, NULL},
	 { (char *)"c3opt_get_nvectors_store", _wrap_c3opt_get_nvectors_store, METH_VARARGS, NULL},
	 { (char *)"c3opt_set_lbfgs_scale", _wrap_c3opt_set_lbfgs_scale, METH_VARARGS, NULL},
	 { (char *)"c3opt_get_lbfgs_scale", _wrap_c3opt_get_lbfgs_scale, METH_VARARGS, NULL},
	 { (char *)"c3opt_is_bruteforce", _wrap_c3opt_is_bruteforce, METH_VARARGS, NULL},
	 { (char *)"c3opt_is_sgd", _wrap_c3opt_is_sgd, METH_VARARGS, NULL},
	 { (char *)"c3opt_add_lb", _wrap_c3opt_add_lb, METH_VARARGS, NULL},
	 { (char *)"c3opt_add_ub", _wrap_c3opt_add_ub, METH_VARARGS, NULL},
	 { (char *)"c3opt_add_objective", _wrap_c3opt_add_objective, METH_VARARGS, NULL},
	 { (char *)"c3opt_add_objective_stoch", _wrap_c3opt_add_objective_stoch, METH_VARARGS, NULL},
	 { (char *)"c3opt_set_verbose", _wrap_c3opt_set_verbose, METH_VARARGS, NULL},
	 { (char *)"c3opt_set_maxiter", _wrap_c3opt_set_maxiter, METH_VARARGS, NULL},
	 { (char *)"c3opt_get_maxiter", _wrap_c3opt_get_maxiter, METH_VARARGS, NULL},
	 { (char *)"c3opt_set_absxtol", _wrap_c3opt_set_absxtol, METH_VARARGS, NULL},
	 { (char *)"c3opt_get_niters", _wrap_c3opt_get_niters, METH_VARARGS, NULL},
	 { (char *)"c3opt_get_stored_function", _wrap_c3opt_get_stored_function, METH_VARARGS, NULL},
	 { (char *)"c3opt_get_nevals", _wrap_c3opt_get_nevals, METH_VARARGS, NULL},
	 { (char *)"c3opt_get_ngvals", _wrap_c3opt_get_ngvals, METH_VARARGS, NULL},
	 { (char *)"c3opt_set_relftol", _wrap_c3opt_set_relftol, METH_VARARGS, NULL},
	 { (char *)"c3opt_set_gtol", _wrap_c3opt_set_gtol, METH_VARARGS, NULL},
	 { (char *)"c3opt_set_storage_options", _wrap_c3opt_set_storage_options, METH_VARARGS, NULL},
	 { (char *)"c3opt_get_store_func", _wrap_c3opt_get_store_func, METH_VARARGS, NULL},
	 { (char *)"c3opt_print_stored_values", _wrap_c3opt_print_stored_values, METH_VARARGS, NULL},
	 { (char *)"c3opt_ls_get_initial", _wrap_c3opt_ls_get_initial, METH_VARARGS, NULL},
	 { (char *)"c3opt_ls_set_alg", _wrap_c3opt_ls_set_alg, METH_VARARGS, NULL},
	 { (char *)"c3opt_ls_get_alg", _wrap_c3opt_ls_get_alg, METH_VARARGS, NULL},
	 { (char *)"c3opt_ls_set_alpha", _wrap_c3opt_ls_set_alpha, METH_VARARGS, NULL},
	 { (char *)"c3opt_ls_get_alpha", _wrap_c3opt_ls_get_alpha, METH_VARARGS, NULL},
	 { (char *)"c3opt_ls_set_beta", _wrap_c3opt_ls_set_beta, METH_VARARGS, NULL},
	 { (char *)"c3opt_ls_get_beta", _wrap_c3opt_ls_get_beta, METH_VARARGS, NULL},
	 { (char *)"c3opt_ls_set_maxiter", _wrap_c3opt_ls_set_maxiter, METH_VARARGS, NULL},
	 { (char *)"c3opt_ls_get_maxiter", _wrap_c3opt_ls_get_maxiter, METH_VARARGS, NULL},
	 { (char *)"c3opt_ls_wolfe_bisect", _wrap_c3opt_ls_wolfe_bisect, METH_VARARGS, NULL},
	 { (char *)"c3opt_ls_strong_wolfe", _wrap_c3opt_ls_strong_wolfe, METH_VARARGS, NULL},
	 { (char *)"c3opt_set_brute_force_vals", _wrap_c3opt_set_brute_force_vals, METH_VARARGS, NULL},
	 { (char *)"c3opt_minimize", _wrap_c3opt_minimize, METH_VARARGS, NULL},
	 { (char *)"c3opt_get_lb", _wrap_c3opt_get_lb, METH_VARARGS, NULL},
	 { (char *)"c3opt_get_ub", _wrap_c3opt_get_ub, METH_VARARGS, NULL},
	 { (char *)"c3opt_eval", _wrap_c3opt_eval, METH_VARARGS, NULL},
	 { (char *)"c3opt_eval_stoch", _wrap_c3opt_eval_stoch, METH_VARARGS, NULL},
	 { (char *)"c3opt_check_deriv", _wrap_c3opt_check_deriv, METH_VARARGS, NULL},
	 { (char *)"c3opt_check_deriv_each", _wrap_c3opt_check_deriv_each, METH_VARARGS, NULL},
	 { (char *)"c3opt_lbfgs_list_alloc", _wrap_c3opt_lbfgs_list_alloc, METH_VARARGS, NULL},
	 { (char *)"c3opt_lbfgs_list_insert", _wrap_c3opt_lbfgs_list_insert, METH_VARARGS, NULL},
	 { (char *)"c3opt_lbfgs_reset_step", _wrap_c3opt_lbfgs_reset_step, METH_VARARGS, NULL},
	 { (char *)"c3opt_lbfgs_list_step", _wrap_c3opt_lbfgs_list_step, METH_VARARGS, NULL},
	 { (char *)"c3opt_lbfgs_list_step_back", _wrap_c3opt_lbfgs_list_step_back, METH_VARARGS, NULL},
	 { (char *)"c3opt_lbfgs_list_print", _wrap_c3opt_lbfgs_list_print, METH_VARARGS, NULL},
	 { (char *)"c3opt_lbfgs_list_free", _wrap_c3opt_lbfgs_list_free, METH_VARARGS, NULL},
	 { (char *)"newton", _wrap_newton, METH_VARARGS, NULL},
	 { (char *)"backtrack_line_search", _wrap_backtrack_line_search, METH_VARARGS, NULL},
	 { (char *)"backtrack_line_search_bc", _wrap_backtrack_line_search_bc, METH_VARARGS, NULL},
	 { (char *)"gradient_descent", _wrap_gradient_descent, METH_VARARGS, NULL},
	 { (char *)"box_pg_descent", _wrap_box_pg_descent, METH_VARARGS, NULL},
	 { (char *)"box_damp_newton", _wrap_box_damp_newton, METH_VARARGS, NULL},
	 { (char *)"box_damp_bfgs", _wrap_box_damp_bfgs, METH_VARARGS, NULL},
	 { (char *)"c3_sobol_sensitivity_calculate", _wrap_c3_sobol_sensitivity_calculate, METH_VARARGS, NULL},
	 { (char *)"c3_sobol_sensitivity_free", _wrap_c3_sobol_sensitivity_free, METH_VARARGS, NULL},
	 { (char *)"c3_sobol_sensitivity_get_interaction", _wrap_c3_sobol_sensitivity_get_interaction, METH_VARARGS, NULL},
	 { (char *)"c3_sobol_sensitivity_get_total", _wrap_c3_sobol_sensitivity_get_total, METH_VARARGS, NULL},
	 { (char *)"c3_sobol_sensitivity_get_main", _wrap_c3_sobol_sensitivity_get_main, METH_VARARGS, NULL},
	 { (char *)"c3_sobol_sensitivity_get_variance", _wrap_c3_sobol_sensitivity_get_variance, METH_VARARGS, NULL},
	 { (char *)"c3_sobol_sensitivity_print", _wrap_c3_sobol_sensitivity_print, METH_VARARGS, NULL},
	 { (char *)"c3_sobol_sensitivity_apply_external", _wrap_c3_sobol_sensitivity_apply_external, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_A_set", _wrap_LinearTransform_A_set, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_A_get", _wrap_LinearTransform_A_get, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_b_set", _wrap_LinearTransform_b_set, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_b_get", _wrap_LinearTransform_b_get, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_det_set", _wrap_LinearTransform_det_set, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_det_get", _wrap_LinearTransform_det_get, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_Ainv_set", _wrap_LinearTransform_Ainv_set, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_Ainv_get", _wrap_LinearTransform_Ainv_get, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_binv_set", _wrap_LinearTransform_binv_set, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_binv_get", _wrap_LinearTransform_binv_get, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_detinv_set", _wrap_LinearTransform_detinv_set, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_detinv_get", _wrap_LinearTransform_detinv_get, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_dimin_set", _wrap_LinearTransform_dimin_set, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_dimin_get", _wrap_LinearTransform_dimin_get, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_dimout_set", _wrap_LinearTransform_dimout_set, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_dimout_get", _wrap_LinearTransform_dimout_get, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_mt_set", _wrap_LinearTransform_mt_set, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_mt_get", _wrap_LinearTransform_mt_get, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_mti_set", _wrap_LinearTransform_mti_set, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_mti_get", _wrap_LinearTransform_mti_get, METH_VARARGS, NULL},
	 { (char *)"new_LinearTransform", _wrap_new_LinearTransform, METH_VARARGS, NULL},
	 { (char *)"delete_LinearTransform", _wrap_delete_LinearTransform, METH_VARARGS, NULL},
	 { (char *)"LinearTransform_swigregister", LinearTransform_swigregister, METH_VARARGS, NULL},
	 { (char *)"ProbabilityDensity_pdf_set", _wrap_ProbabilityDensity_pdf_set, METH_VARARGS, NULL},
	 { (char *)"ProbabilityDensity_pdf_get", _wrap_ProbabilityDensity_pdf_get, METH_VARARGS, NULL},
	 { (char *)"ProbabilityDensity_lt_set", _wrap_ProbabilityDensity_lt_set, METH_VARARGS, NULL},
	 { (char *)"ProbabilityDensity_lt_get", _wrap_ProbabilityDensity_lt_get, METH_VARARGS, NULL},
	 { (char *)"ProbabilityDensity_transform_set", _wrap_ProbabilityDensity_transform_set, METH_VARARGS, NULL},
	 { (char *)"ProbabilityDensity_transform_get", _wrap_ProbabilityDensity_transform_get, METH_VARARGS, NULL},
	 { (char *)"ProbabilityDensity_type_set", _wrap_ProbabilityDensity_type_set, METH_VARARGS, NULL},
	 { (char *)"ProbabilityDensity_type_get", _wrap_ProbabilityDensity_type_get, METH_VARARGS, NULL},
	 { (char *)"ProbabilityDensity_extra_set", _wrap_ProbabilityDensity_extra_set, METH_VARARGS, NULL},
	 { (char *)"ProbabilityDensity_extra_get", _wrap_ProbabilityDensity_extra_get, METH_VARARGS, NULL},
	 { (char *)"new_ProbabilityDensity", _wrap_new_ProbabilityDensity, METH_VARARGS, NULL},
	 { (char *)"delete_ProbabilityDensity", _wrap_delete_ProbabilityDensity, METH_VARARGS, NULL},
	 { (char *)"ProbabilityDensity_swigregister", ProbabilityDensity_swigregister, METH_VARARGS, NULL},
	 { (char *)"linear_transform_alloc", _wrap_linear_transform_alloc, METH_VARARGS, NULL},
	 { (char *)"linear_transform_copy", _wrap_linear_transform_copy, METH_VARARGS, NULL},
	 { (char *)"linear_transform_free", _wrap_linear_transform_free, METH_VARARGS, NULL},
	 { (char *)"linear_transform_apply", _wrap_linear_transform_apply, METH_VARARGS, NULL},
	 { (char *)"linear_transform_invert", _wrap_linear_transform_invert, METH_VARARGS, NULL},
	 { (char *)"linear_transform_serialize", _wrap_linear_transform_serialize, METH_VARARGS, NULL},
	 { (char *)"linear_transform_deserialize", _wrap_linear_transform_deserialize, METH_VARARGS, NULL},
	 { (char *)"probability_density_alloc", _wrap_probability_density_alloc, METH_VARARGS, NULL},
	 { (char *)"probability_density_free", _wrap_probability_density_free, METH_VARARGS, NULL},
	 { (char *)"probability_density_serialize", _wrap_probability_density_serialize, METH_VARARGS, NULL},
	 { (char *)"probability_density_deserialize", _wrap_probability_density_deserialize, METH_VARARGS, NULL},
	 { (char *)"probability_density_save", _wrap_probability_density_save, METH_VARARGS, NULL},
	 { (char *)"probability_density_load", _wrap_probability_density_load, METH_VARARGS, NULL},
	 { (char *)"probability_density_eval", _wrap_probability_density_eval, METH_VARARGS, NULL},
	 { (char *)"probability_density_log_gradient_eval", _wrap_probability_density_log_gradient_eval, METH_VARARGS, NULL},
	 { (char *)"probability_density_log_hessian_eval", _wrap_probability_density_log_hessian_eval, METH_VARARGS, NULL},
	 { (char *)"probability_density_lb_base", _wrap_probability_density_lb_base, METH_VARARGS, NULL},
	 { (char *)"probability_density_ub_base", _wrap_probability_density_ub_base, METH_VARARGS, NULL},
	 { (char *)"probability_density_standard_normal", _wrap_probability_density_standard_normal, METH_VARARGS, NULL},
	 { (char *)"probability_density_mvn", _wrap_probability_density_mvn, METH_VARARGS, NULL},
	 { (char *)"probability_density_sample", _wrap_probability_density_sample, METH_VARARGS, NULL},
	 { (char *)"probability_density_laplace", _wrap_probability_density_laplace, METH_VARARGS, NULL},
	 { (char *)"Likelihood_datadim_set", _wrap_Likelihood_datadim_set, METH_VARARGS, NULL},
	 { (char *)"Likelihood_datadim_get", _wrap_Likelihood_datadim_get, METH_VARARGS, NULL},
	 { (char *)"Likelihood_paramdim_set", _wrap_Likelihood_paramdim_set, METH_VARARGS, NULL},
	 { (char *)"Likelihood_paramdim_get", _wrap_Likelihood_paramdim_get, METH_VARARGS, NULL},
	 { (char *)"Likelihood_inputdim_set", _wrap_Likelihood_inputdim_set, METH_VARARGS, NULL},
	 { (char *)"Likelihood_inputdim_get", _wrap_Likelihood_inputdim_get, METH_VARARGS, NULL},
	 { (char *)"Likelihood_type_set", _wrap_Likelihood_type_set, METH_VARARGS, NULL},
	 { (char *)"Likelihood_type_get", _wrap_Likelihood_type_get, METH_VARARGS, NULL},
	 { (char *)"Likelihood_like_set", _wrap_Likelihood_like_set, METH_VARARGS, NULL},
	 { (char *)"Likelihood_like_get", _wrap_Likelihood_like_get, METH_VARARGS, NULL},
	 { (char *)"Likelihood_loglike_set", _wrap_Likelihood_loglike_set, METH_VARARGS, NULL},
	 { (char *)"Likelihood_loglike_get", _wrap_Likelihood_loglike_get, METH_VARARGS, NULL},
	 { (char *)"Likelihood_logextra_set", _wrap_Likelihood_logextra_set, METH_VARARGS, NULL},
	 { (char *)"Likelihood_logextra_get", _wrap_Likelihood_logextra_get, METH_VARARGS, NULL},
	 { (char *)"new_Likelihood", _wrap_new_Likelihood, METH_VARARGS, NULL},
	 { (char *)"delete_Likelihood", _wrap_delete_Likelihood, METH_VARARGS, NULL},
	 { (char *)"Likelihood_swigregister", Likelihood_swigregister, METH_VARARGS, NULL},
	 { (char *)"likelihood_free", _wrap_likelihood_free, METH_VARARGS, NULL},
	 { (char *)"BayesRule_like_set", _wrap_BayesRule_like_set, METH_VARARGS, NULL},
	 { (char *)"BayesRule_like_get", _wrap_BayesRule_like_get, METH_VARARGS, NULL},
	 { (char *)"BayesRule_prior_set", _wrap_BayesRule_prior_set, METH_VARARGS, NULL},
	 { (char *)"BayesRule_prior_get", _wrap_BayesRule_prior_get, METH_VARARGS, NULL},
	 { (char *)"new_BayesRule", _wrap_new_BayesRule, METH_VARARGS, NULL},
	 { (char *)"delete_BayesRule", _wrap_delete_BayesRule, METH_VARARGS, NULL},
	 { (char *)"BayesRule_swigregister", BayesRule_swigregister, METH_VARARGS, NULL},
	 { (char *)"trap_w", _wrap_trap_w, METH_VARARGS, NULL},
	 { (char *)"simpson_w", _wrap_simpson_w, METH_VARARGS, NULL},
	 { (char *)"clenshaw_curtis", _wrap_clenshaw_curtis, METH_VARARGS, NULL},
	 { (char *)"rescale_cc", _wrap_rescale_cc, METH_VARARGS, NULL},
	 { (char *)"fejer2", _wrap_fejer2, METH_VARARGS, NULL},
	 { (char *)"cheb_gauss", _wrap_cheb_gauss, METH_VARARGS, NULL},
	 { (char *)"gauss_hermite", _wrap_gauss_hermite, METH_VARARGS, NULL},
	 { (char *)"gauss_legendre", _wrap_gauss_legendre, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static swig_type_info _swigt__p_BayesRule = {"_p_BayesRule", "struct BayesRule *|BayesRule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BoundingBox = {"_p_BoundingBox", "struct BoundingBox *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_C3Approx = {"_p_C3Approx", "struct C3Approx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_C3SobolSensitivity = {"_p_C3SobolSensitivity", "struct C3SobolSensitivity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CVOptGrid = {"_p_CVOptGrid", "struct CVOptGrid *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Cpair = {"_p_Cpair", "struct Cpair *|Cpair *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CrossIndex = {"_p_CrossIndex", "struct CrossIndex *|CrossIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CrossNode = {"_p_CrossNode", "struct CrossNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CrossValidate = {"_p_CrossValidate", "struct CrossValidate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Data = {"_p_Data", "struct Data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DmDiff = {"_p_DmDiff", "struct DmDiff *|DmDiff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DmProd = {"_p_DmProd", "struct DmProd *|DmProd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FT1DArray = {"_p_FT1DArray", "struct FT1DArray *|FT1DArray *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FTMemSpace = {"_p_FTMemSpace", "struct FTMemSpace *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FTRegress = {"_p_FTRegress", "struct FTRegress *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FTparam = {"_p_FTparam", "struct FTparam *|FTparam *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FiberCut = {"_p_FiberCut", "struct FiberCut *|FiberCut *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FiberOptArgs = {"_p_FiberOptArgs", "struct FiberOptArgs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FtCrossArgs = {"_p_FtCrossArgs", "struct FtCrossArgs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FunctionMonitor = {"_p_FunctionMonitor", "struct FunctionMonitor *|FunctionMonitor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FunctionTrain = {"_p_FunctionTrain", "struct FunctionTrain *|FunctionTrain *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fwrap = {"_p_Fwrap", "struct Fwrap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GenericFunction = {"_p_GenericFunction", "struct GenericFunction *|GenericFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HashtableCpair = {"_p_HashtableCpair", "struct HashtableCpair *|HashtableCpair *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Kernel = {"_p_Kernel", "struct Kernel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_KernelApproxOpts = {"_p_KernelApproxOpts", "struct KernelApproxOpts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_KernelExpansion = {"_p_KernelExpansion", "struct KernelExpansion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LeastSquaresArgs = {"_p_LeastSquaresArgs", "struct LeastSquaresArgs *|LeastSquaresArgs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Likelihood = {"_p_Likelihood", "struct Likelihood *|Likelihood *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LinElemExp = {"_p_LinElemExp", "struct LinElemExp *|LinElemExp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LinElemExpAopts = {"_p_LinElemExpAopts", "struct LinElemExpAopts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LinElemXY = {"_p_LinElemXY", "struct LinElemXY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LinearTransform = {"_p_LinearTransform", "struct LinearTransform *|LinearTransform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MultiApproxOpts = {"_p_MultiApproxOpts", "struct MultiApproxOpts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ObjectiveFunction = {"_p_ObjectiveFunction", "struct ObjectiveFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OneApproxOpts = {"_p_OneApproxOpts", "struct OneApproxOpts *|OneApproxOpts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OpeOpts = {"_p_OpeOpts", "struct OpeOpts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Operator = {"_p_Operator", "struct Operator *|Operator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OrthPoly = {"_p_OrthPoly", "struct OrthPoly *|OrthPoly *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OrthPolyExpansion = {"_p_OrthPolyExpansion", "struct OrthPolyExpansion *|OrthPolyExpansion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PairList = {"_p_PairList", "struct PairList *|PairList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewisePoly = {"_p_PiecewisePoly", "struct PiecewisePoly *|PiecewisePoly *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pivot = {"_p_Pivot", "struct Pivot *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PivotSet = {"_p_PivotSet", "struct PivotSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ProbabilityDensity = {"_p_ProbabilityDensity", "struct ProbabilityDensity *|ProbabilityDensity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PwPolyOpts = {"_p_PwPolyOpts", "struct PwPolyOpts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QR = {"_p_QR", "QR *|struct QR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Qmarray = {"_p_Qmarray", "struct Qmarray *|Qmarray *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Quasimatrix = {"_p_Quasimatrix", "struct Quasimatrix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Regress1DOpts = {"_p_Regress1DOpts", "struct Regress1DOpts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RegressOpts = {"_p_RegressOpts", "struct RegressOpts *|RegressOpts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SLMemManager = {"_p_SLMemManager", "struct SLMemManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SLP = {"_p_SLP", "SLP *|struct SLP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SpaceMapping = {"_p_SpaceMapping", "struct SpaceMapping *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StandardPoly = {"_p_StandardPoly", "struct StandardPoly *|StandardPoly *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_c3Opt = {"_p_c3Opt", "struct c3Opt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_c3Vector = {"_p_c3Vector", "struct c3Vector *|c3Vector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_c3opt_lbfgs_list = {"_p_c3opt_lbfgs_list", "struct c3opt_lbfgs_list *", 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_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double_complex = {"_p_double_complex", "double complex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_char_unsigned_long_unsigned_long_p_double_p_p_struct_Qmarray_p_void__void = {"_p_f_char_unsigned_long_unsigned_long_p_double_p_p_struct_Qmarray_p_void__void", "void (*)(char,unsigned long,unsigned long,double *,struct Qmarray **,void *)|void (*)(char,size_t,size_t,double *,struct Qmarray **,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_double_double_p_void__double = {"_p_f_double_double_p_void__double", "double (*)(double,double,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_double_p_void__double = {"_p_f_double_p_void__double", "double (*)(double,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_double_unsigned_long_p_unsigned_long_p_void__void = {"_p_f_double_unsigned_long_p_unsigned_long_p_void__void", "void (*)(double,unsigned long,unsigned long *,void *)|void (*)(double,size_t,size_t *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_int_int_int_p_void__double = {"_p_f_int_int_int_p_void__double", "double (*)(int,int,int,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_double_double_unsigned_long_unsigned_long_p_double_p_void__int = {"_p_f_p_double_double_unsigned_long_unsigned_long_p_double_p_void__int", "int (*)(double *,double,unsigned long,unsigned long,double *,void *)|int (*)(double *,double,size_t,size_t,double *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_double_p_double_p_void__int = {"_p_f_p_double_p_double_p_void__int", "int (*)(double *,double *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_double_p_void__double = {"_p_f_p_double_p_void__double", "double (*)(double *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_double_p_void__p_double = {"_p_f_p_double_p_void__p_double", "double *(*)(double *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__double_p_void__double = {"_p_f_p_q_const__double_p_void__double", "double (*)(double const *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__struct_GenericFunction_p_void__p_GenericFunction = {"_p_f_p_q_const__struct_GenericFunction_p_void__p_GenericFunction", "struct GenericFunction *(*)(struct GenericFunction const *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__unsigned_long_p_void__double = {"_p_f_p_q_const__unsigned_long_p_void__double", "double (*)(unsigned long const *,void *)|double (*)(size_t const *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_unsigned_long__double = {"_p_f_unsigned_long__double", "double (*)(size_t)|double (*)(unsigned long)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_unsigned_long_p_q_const__double_p_double_p_void__double = {"_p_f_unsigned_long_p_q_const__double_p_double_p_void__double", "double (*)(size_t,double const *,double *,void *)|double (*)(unsigned long,double const *,double *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_unsigned_long_p_q_const__double_p_double_p_void__int = {"_p_f_unsigned_long_p_q_const__double_p_double_p_void__int", "int (*)(unsigned long,double const *,double *,void *)|int (*)(size_t,double const *,double *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_unsigned_long_p_q_const__double_p_double_unsigned_long_p_unsigned_long_p_struct_Data_p_struct_SLMemManager_p_void__double = {"_p_f_unsigned_long_p_q_const__double_p_double_unsigned_long_p_unsigned_long_p_struct_Data_p_struct_SLMemManager_p_void__double", "double (*)(size_t,double const *,double *,size_t,size_t *,struct Data *,struct SLMemManager *,void *)|double (*)(unsigned long,double const *,double *,unsigned long,unsigned long *,struct Data *,struct SLMemManager *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_unsigned_long_p_q_const__double_unsigned_long_p_unsigned_long_p_struct_SLMemManager_p_struct_Data_p_p_double_p_p_double_p_void__int = {"_p_f_unsigned_long_p_q_const__double_unsigned_long_p_unsigned_long_p_struct_SLMemManager_p_struct_Data_p_p_double_p_p_double_p_void__int", "int (*)(unsigned long,double const *,unsigned long,unsigned long *,struct SLMemManager *,struct Data *,double **,double **,void *)|int (*)(size_t,double const *,size_t,size_t *,struct SLMemManager *,struct Data *,double **,double **,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__double = {"_p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__double", "double (*)(unsigned long,unsigned long,double const *,double *,void *)|double (*)(size_t,size_t,double const *,double *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__int = {"_p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__int", "int (*)(unsigned long,unsigned long,double const *,double *,void *)|int (*)(size_t,size_t,double const *,double *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ff = {"_p_ff", "ff *|union ff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_fiber_info = {"_p_fiber_info", "struct fiber_info *|fiber_info *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_fiber_list = {"_p_fiber_list", "struct fiber_list *|fiber_list *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_func_type = {"_p_func_type", "union func_type *|func_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_function_class = {"_p_function_class", "enum function_class *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_double = {"_p_long_double", "long double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mat = {"_p_mat", "mat *|struct mat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_CrossIndex = {"_p_p_CrossIndex", "struct CrossIndex **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_FT1DArray = {"_p_p_FT1DArray", "struct FT1DArray **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_FTMemSpace = {"_p_p_FTMemSpace", "struct FTMemSpace **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_FiberCut = {"_p_p_FiberCut", "struct FiberCut **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_FunctionTrain = {"_p_p_FunctionTrain", "struct FunctionTrain **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_GenericFunction = {"_p_p_GenericFunction", "struct GenericFunction **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_KernelExpansion = {"_p_p_KernelExpansion", "struct KernelExpansion **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_LinElemExp = {"_p_p_LinElemExp", "struct LinElemExp **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_LinElemExpAopts = {"_p_p_LinElemExpAopts", "struct LinElemExpAopts **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_LinElemXY = {"_p_p_LinElemXY", "struct LinElemXY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_LinearTransform = {"_p_p_LinearTransform", "struct LinearTransform **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_MultiApproxOpts = {"_p_p_MultiApproxOpts", "struct MultiApproxOpts **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_ObjectiveFunction = {"_p_p_ObjectiveFunction", "struct ObjectiveFunction **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_OneApproxOpts = {"_p_p_OneApproxOpts", "struct OneApproxOpts **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_OpeOpts = {"_p_p_OpeOpts", "struct OpeOpts **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_Operator = {"_p_p_Operator", "struct Operator **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_OrthPolyExpansion = {"_p_p_OrthPolyExpansion", "struct OrthPolyExpansion **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_PairList = {"_p_p_PairList", "struct PairList **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_PiecewisePoly = {"_p_p_PiecewisePoly", "struct PiecewisePoly **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_ProbabilityDensity = {"_p_p_ProbabilityDensity", "struct ProbabilityDensity **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_PwPolyOpts = {"_p_p_PwPolyOpts", "struct PwPolyOpts **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_QR = {"_p_p_QR", "struct QR **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_Qmarray = {"_p_p_Qmarray", "struct Qmarray **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_Quasimatrix = {"_p_p_Quasimatrix", "struct Quasimatrix **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_c3Vector = {"_p_p_c3Vector", "struct c3Vector **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_fiber_list = {"_p_p_fiber_list", "struct fiber_list **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_mat = {"_p_p_mat", "struct mat **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_p_GenericFunction = {"_p_p_p_GenericFunction", "struct GenericFunction ***", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_sk_decomp = {"_p_p_sk_decomp", "struct sk_decomp **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_storevals = {"_p_p_storevals", "struct storevals **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sk_decomp = {"_p_sk_decomp", "struct sk_decomp *|sk_decomp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_storevals = {"_p_storevals", "struct storevals *|storevals *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_storevals_main = {"_p_storevals_main", "struct storevals_main *|storevals_main *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "size_t *|unsigned long *", 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_BayesRule,
  &_swigt__p_BoundingBox,
  &_swigt__p_C3Approx,
  &_swigt__p_C3SobolSensitivity,
  &_swigt__p_CVOptGrid,
  &_swigt__p_Cpair,
  &_swigt__p_CrossIndex,
  &_swigt__p_CrossNode,
  &_swigt__p_CrossValidate,
  &_swigt__p_Data,
  &_swigt__p_DmDiff,
  &_swigt__p_DmProd,
  &_swigt__p_FILE,
  &_swigt__p_FT1DArray,
  &_swigt__p_FTMemSpace,
  &_swigt__p_FTRegress,
  &_swigt__p_FTparam,
  &_swigt__p_FiberCut,
  &_swigt__p_FiberOptArgs,
  &_swigt__p_FtCrossArgs,
  &_swigt__p_FunctionMonitor,
  &_swigt__p_FunctionTrain,
  &_swigt__p_Fwrap,
  &_swigt__p_GenericFunction,
  &_swigt__p_HashtableCpair,
  &_swigt__p_Kernel,
  &_swigt__p_KernelApproxOpts,
  &_swigt__p_KernelExpansion,
  &_swigt__p_LeastSquaresArgs,
  &_swigt__p_Likelihood,
  &_swigt__p_LinElemExp,
  &_swigt__p_LinElemExpAopts,
  &_swigt__p_LinElemXY,
  &_swigt__p_LinearTransform,
  &_swigt__p_MultiApproxOpts,
  &_swigt__p_ObjectiveFunction,
  &_swigt__p_OneApproxOpts,
  &_swigt__p_OpeOpts,
  &_swigt__p_Operator,
  &_swigt__p_OrthPoly,
  &_swigt__p_OrthPolyExpansion,
  &_swigt__p_PairList,
  &_swigt__p_PiecewisePoly,
  &_swigt__p_Pivot,
  &_swigt__p_PivotSet,
  &_swigt__p_ProbabilityDensity,
  &_swigt__p_PwPolyOpts,
  &_swigt__p_QR,
  &_swigt__p_Qmarray,
  &_swigt__p_Quasimatrix,
  &_swigt__p_Regress1DOpts,
  &_swigt__p_RegressOpts,
  &_swigt__p_SLMemManager,
  &_swigt__p_SLP,
  &_swigt__p_SpaceMapping,
  &_swigt__p_StandardPoly,
  &_swigt__p_c3Opt,
  &_swigt__p_c3Vector,
  &_swigt__p_c3opt_lbfgs_list,
  &_swigt__p_char,
  &_swigt__p_double,
  &_swigt__p_double_complex,
  &_swigt__p_f_char_unsigned_long_unsigned_long_p_double_p_p_struct_Qmarray_p_void__void,
  &_swigt__p_f_double_double_p_void__double,
  &_swigt__p_f_double_p_void__double,
  &_swigt__p_f_double_unsigned_long_p_unsigned_long_p_void__void,
  &_swigt__p_f_int_int_int_p_void__double,
  &_swigt__p_f_p_double_double_unsigned_long_unsigned_long_p_double_p_void__int,
  &_swigt__p_f_p_double_p_double_p_void__int,
  &_swigt__p_f_p_double_p_void__double,
  &_swigt__p_f_p_double_p_void__p_double,
  &_swigt__p_f_p_q_const__double_p_void__double,
  &_swigt__p_f_p_q_const__struct_GenericFunction_p_void__p_GenericFunction,
  &_swigt__p_f_p_q_const__unsigned_long_p_void__double,
  &_swigt__p_f_unsigned_long__double,
  &_swigt__p_f_unsigned_long_p_q_const__double_p_double_p_void__double,
  &_swigt__p_f_unsigned_long_p_q_const__double_p_double_p_void__int,
  &_swigt__p_f_unsigned_long_p_q_const__double_p_double_unsigned_long_p_unsigned_long_p_struct_Data_p_struct_SLMemManager_p_void__double,
  &_swigt__p_f_unsigned_long_p_q_const__double_unsigned_long_p_unsigned_long_p_struct_SLMemManager_p_struct_Data_p_p_double_p_p_double_p_void__int,
  &_swigt__p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__double,
  &_swigt__p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__int,
  &_swigt__p_ff,
  &_swigt__p_fiber_info,
  &_swigt__p_fiber_list,
  &_swigt__p_func_type,
  &_swigt__p_function_class,
  &_swigt__p_int,
  &_swigt__p_long_double,
  &_swigt__p_mat,
  &_swigt__p_p_CrossIndex,
  &_swigt__p_p_FT1DArray,
  &_swigt__p_p_FTMemSpace,
  &_swigt__p_p_FiberCut,
  &_swigt__p_p_FunctionTrain,
  &_swigt__p_p_GenericFunction,
  &_swigt__p_p_KernelExpansion,
  &_swigt__p_p_LinElemExp,
  &_swigt__p_p_LinElemExpAopts,
  &_swigt__p_p_LinElemXY,
  &_swigt__p_p_LinearTransform,
  &_swigt__p_p_MultiApproxOpts,
  &_swigt__p_p_ObjectiveFunction,
  &_swigt__p_p_OneApproxOpts,
  &_swigt__p_p_OpeOpts,
  &_swigt__p_p_Operator,
  &_swigt__p_p_OrthPolyExpansion,
  &_swigt__p_p_PairList,
  &_swigt__p_p_PiecewisePoly,
  &_swigt__p_p_ProbabilityDensity,
  &_swigt__p_p_PwPolyOpts,
  &_swigt__p_p_QR,
  &_swigt__p_p_Qmarray,
  &_swigt__p_p_Quasimatrix,
  &_swigt__p_p_c3Vector,
  &_swigt__p_p_char,
  &_swigt__p_p_double,
  &_swigt__p_p_fiber_list,
  &_swigt__p_p_mat,
  &_swigt__p_p_p_GenericFunction,
  &_swigt__p_p_sk_decomp,
  &_swigt__p_p_storevals,
  &_swigt__p_p_void,
  &_swigt__p_sk_decomp,
  &_swigt__p_storevals,
  &_swigt__p_storevals_main,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_long,
  &_swigt__p_void,
};

static swig_cast_info _swigc__p_BayesRule[] = {  {&_swigt__p_BayesRule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BoundingBox[] = {  {&_swigt__p_BoundingBox, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_C3Approx[] = {  {&_swigt__p_C3Approx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_C3SobolSensitivity[] = {  {&_swigt__p_C3SobolSensitivity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CVOptGrid[] = {  {&_swigt__p_CVOptGrid, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Cpair[] = {  {&_swigt__p_Cpair, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CrossIndex[] = {  {&_swigt__p_CrossIndex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CrossNode[] = {  {&_swigt__p_CrossNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CrossValidate[] = {  {&_swigt__p_CrossValidate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Data[] = {  {&_swigt__p_Data, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DmDiff[] = {  {&_swigt__p_DmDiff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DmProd[] = {  {&_swigt__p_DmProd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FILE[] = {  {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FT1DArray[] = {  {&_swigt__p_FT1DArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FTMemSpace[] = {  {&_swigt__p_FTMemSpace, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FTRegress[] = {  {&_swigt__p_FTRegress, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FTparam[] = {  {&_swigt__p_FTparam, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FiberCut[] = {  {&_swigt__p_FiberCut, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FiberOptArgs[] = {  {&_swigt__p_FiberOptArgs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FtCrossArgs[] = {  {&_swigt__p_FtCrossArgs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FunctionMonitor[] = {  {&_swigt__p_FunctionMonitor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FunctionTrain[] = {  {&_swigt__p_FunctionTrain, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fwrap[] = {  {&_swigt__p_Fwrap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GenericFunction[] = {  {&_swigt__p_GenericFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HashtableCpair[] = {  {&_swigt__p_HashtableCpair, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Kernel[] = {  {&_swigt__p_Kernel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_KernelApproxOpts[] = {  {&_swigt__p_KernelApproxOpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_KernelExpansion[] = {  {&_swigt__p_KernelExpansion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LeastSquaresArgs[] = {  {&_swigt__p_LeastSquaresArgs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Likelihood[] = {  {&_swigt__p_Likelihood, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LinElemExp[] = {  {&_swigt__p_LinElemExp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LinElemExpAopts[] = {  {&_swigt__p_LinElemExpAopts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LinElemXY[] = {  {&_swigt__p_LinElemXY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LinearTransform[] = {  {&_swigt__p_LinearTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MultiApproxOpts[] = {  {&_swigt__p_MultiApproxOpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ObjectiveFunction[] = {  {&_swigt__p_ObjectiveFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OneApproxOpts[] = {  {&_swigt__p_OneApproxOpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OpeOpts[] = {  {&_swigt__p_OpeOpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Operator[] = {  {&_swigt__p_Operator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OrthPoly[] = {  {&_swigt__p_OrthPoly, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OrthPolyExpansion[] = {  {&_swigt__p_OrthPolyExpansion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PairList[] = {  {&_swigt__p_PairList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewisePoly[] = {  {&_swigt__p_PiecewisePoly, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pivot[] = {  {&_swigt__p_Pivot, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PivotSet[] = {  {&_swigt__p_PivotSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ProbabilityDensity[] = {  {&_swigt__p_ProbabilityDensity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PwPolyOpts[] = {  {&_swigt__p_PwPolyOpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QR[] = {  {&_swigt__p_QR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Qmarray[] = {  {&_swigt__p_Qmarray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Quasimatrix[] = {  {&_swigt__p_Quasimatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Regress1DOpts[] = {  {&_swigt__p_Regress1DOpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RegressOpts[] = {  {&_swigt__p_RegressOpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SLMemManager[] = {  {&_swigt__p_SLMemManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SLP[] = {  {&_swigt__p_SLP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SpaceMapping[] = {  {&_swigt__p_SpaceMapping, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StandardPoly[] = {  {&_swigt__p_StandardPoly, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_c3Opt[] = {  {&_swigt__p_c3Opt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_c3Vector[] = {  {&_swigt__p_c3Vector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_c3opt_lbfgs_list[] = {  {&_swigt__p_c3opt_lbfgs_list, 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_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double_complex[] = {  {&_swigt__p_double_complex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_char_unsigned_long_unsigned_long_p_double_p_p_struct_Qmarray_p_void__void[] = {  {&_swigt__p_f_char_unsigned_long_unsigned_long_p_double_p_p_struct_Qmarray_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_double_double_p_void__double[] = {  {&_swigt__p_f_double_double_p_void__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_double_p_void__double[] = {  {&_swigt__p_f_double_p_void__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_double_unsigned_long_p_unsigned_long_p_void__void[] = {  {&_swigt__p_f_double_unsigned_long_p_unsigned_long_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_int_int_int_p_void__double[] = {  {&_swigt__p_f_int_int_int_p_void__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_double_double_unsigned_long_unsigned_long_p_double_p_void__int[] = {  {&_swigt__p_f_p_double_double_unsigned_long_unsigned_long_p_double_p_void__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_double_p_double_p_void__int[] = {  {&_swigt__p_f_p_double_p_double_p_void__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_double_p_void__double[] = {  {&_swigt__p_f_p_double_p_void__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_double_p_void__p_double[] = {  {&_swigt__p_f_p_double_p_void__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__double_p_void__double[] = {  {&_swigt__p_f_p_q_const__double_p_void__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__struct_GenericFunction_p_void__p_GenericFunction[] = {  {&_swigt__p_f_p_q_const__struct_GenericFunction_p_void__p_GenericFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__unsigned_long_p_void__double[] = {  {&_swigt__p_f_p_q_const__unsigned_long_p_void__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_unsigned_long__double[] = {  {&_swigt__p_f_unsigned_long__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_unsigned_long_p_q_const__double_p_double_p_void__double[] = {  {&_swigt__p_f_unsigned_long_p_q_const__double_p_double_p_void__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_unsigned_long_p_q_const__double_p_double_p_void__int[] = {  {&_swigt__p_f_unsigned_long_p_q_const__double_p_double_p_void__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_unsigned_long_p_q_const__double_p_double_unsigned_long_p_unsigned_long_p_struct_Data_p_struct_SLMemManager_p_void__double[] = {  {&_swigt__p_f_unsigned_long_p_q_const__double_p_double_unsigned_long_p_unsigned_long_p_struct_Data_p_struct_SLMemManager_p_void__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_unsigned_long_p_q_const__double_unsigned_long_p_unsigned_long_p_struct_SLMemManager_p_struct_Data_p_p_double_p_p_double_p_void__int[] = {  {&_swigt__p_f_unsigned_long_p_q_const__double_unsigned_long_p_unsigned_long_p_struct_SLMemManager_p_struct_Data_p_p_double_p_p_double_p_void__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__double[] = {  {&_swigt__p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__int[] = {  {&_swigt__p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ff[] = {  {&_swigt__p_ff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_fiber_info[] = {  {&_swigt__p_fiber_info, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_fiber_list[] = {  {&_swigt__p_fiber_list, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_func_type[] = {  {&_swigt__p_func_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_function_class[] = {  {&_swigt__p_function_class, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_double[] = {  {&_swigt__p_long_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mat[] = {  {&_swigt__p_mat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CrossIndex[] = {  {&_swigt__p_p_CrossIndex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_FT1DArray[] = {  {&_swigt__p_p_FT1DArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_FTMemSpace[] = {  {&_swigt__p_p_FTMemSpace, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_FiberCut[] = {  {&_swigt__p_p_FiberCut, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_FunctionTrain[] = {  {&_swigt__p_p_FunctionTrain, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_GenericFunction[] = {  {&_swigt__p_p_GenericFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_KernelExpansion[] = {  {&_swigt__p_p_KernelExpansion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_LinElemExp[] = {  {&_swigt__p_p_LinElemExp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_LinElemExpAopts[] = {  {&_swigt__p_p_LinElemExpAopts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_LinElemXY[] = {  {&_swigt__p_p_LinElemXY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_LinearTransform[] = {  {&_swigt__p_p_LinearTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_MultiApproxOpts[] = {  {&_swigt__p_p_MultiApproxOpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ObjectiveFunction[] = {  {&_swigt__p_p_ObjectiveFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_OneApproxOpts[] = {  {&_swigt__p_p_OneApproxOpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_OpeOpts[] = {  {&_swigt__p_p_OpeOpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Operator[] = {  {&_swigt__p_p_Operator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_OrthPolyExpansion[] = {  {&_swigt__p_p_OrthPolyExpansion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_PairList[] = {  {&_swigt__p_p_PairList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_PiecewisePoly[] = {  {&_swigt__p_p_PiecewisePoly, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ProbabilityDensity[] = {  {&_swigt__p_p_ProbabilityDensity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_PwPolyOpts[] = {  {&_swigt__p_p_PwPolyOpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_QR[] = {  {&_swigt__p_p_QR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Qmarray[] = {  {&_swigt__p_p_Qmarray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Quasimatrix[] = {  {&_swigt__p_p_Quasimatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_c3Vector[] = {  {&_swigt__p_p_c3Vector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_double[] = {  {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_fiber_list[] = {  {&_swigt__p_p_fiber_list, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_mat[] = {  {&_swigt__p_p_mat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_p_GenericFunction[] = {  {&_swigt__p_p_p_GenericFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_sk_decomp[] = {  {&_swigt__p_p_sk_decomp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_storevals[] = {  {&_swigt__p_p_storevals, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sk_decomp[] = {  {&_swigt__p_sk_decomp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_storevals[] = {  {&_swigt__p_storevals, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_storevals_main[] = {  {&_swigt__p_storevals_main, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 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_BayesRule,
  _swigc__p_BoundingBox,
  _swigc__p_C3Approx,
  _swigc__p_C3SobolSensitivity,
  _swigc__p_CVOptGrid,
  _swigc__p_Cpair,
  _swigc__p_CrossIndex,
  _swigc__p_CrossNode,
  _swigc__p_CrossValidate,
  _swigc__p_Data,
  _swigc__p_DmDiff,
  _swigc__p_DmProd,
  _swigc__p_FILE,
  _swigc__p_FT1DArray,
  _swigc__p_FTMemSpace,
  _swigc__p_FTRegress,
  _swigc__p_FTparam,
  _swigc__p_FiberCut,
  _swigc__p_FiberOptArgs,
  _swigc__p_FtCrossArgs,
  _swigc__p_FunctionMonitor,
  _swigc__p_FunctionTrain,
  _swigc__p_Fwrap,
  _swigc__p_GenericFunction,
  _swigc__p_HashtableCpair,
  _swigc__p_Kernel,
  _swigc__p_KernelApproxOpts,
  _swigc__p_KernelExpansion,
  _swigc__p_LeastSquaresArgs,
  _swigc__p_Likelihood,
  _swigc__p_LinElemExp,
  _swigc__p_LinElemExpAopts,
  _swigc__p_LinElemXY,
  _swigc__p_LinearTransform,
  _swigc__p_MultiApproxOpts,
  _swigc__p_ObjectiveFunction,
  _swigc__p_OneApproxOpts,
  _swigc__p_OpeOpts,
  _swigc__p_Operator,
  _swigc__p_OrthPoly,
  _swigc__p_OrthPolyExpansion,
  _swigc__p_PairList,
  _swigc__p_PiecewisePoly,
  _swigc__p_Pivot,
  _swigc__p_PivotSet,
  _swigc__p_ProbabilityDensity,
  _swigc__p_PwPolyOpts,
  _swigc__p_QR,
  _swigc__p_Qmarray,
  _swigc__p_Quasimatrix,
  _swigc__p_Regress1DOpts,
  _swigc__p_RegressOpts,
  _swigc__p_SLMemManager,
  _swigc__p_SLP,
  _swigc__p_SpaceMapping,
  _swigc__p_StandardPoly,
  _swigc__p_c3Opt,
  _swigc__p_c3Vector,
  _swigc__p_c3opt_lbfgs_list,
  _swigc__p_char,
  _swigc__p_double,
  _swigc__p_double_complex,
  _swigc__p_f_char_unsigned_long_unsigned_long_p_double_p_p_struct_Qmarray_p_void__void,
  _swigc__p_f_double_double_p_void__double,
  _swigc__p_f_double_p_void__double,
  _swigc__p_f_double_unsigned_long_p_unsigned_long_p_void__void,
  _swigc__p_f_int_int_int_p_void__double,
  _swigc__p_f_p_double_double_unsigned_long_unsigned_long_p_double_p_void__int,
  _swigc__p_f_p_double_p_double_p_void__int,
  _swigc__p_f_p_double_p_void__double,
  _swigc__p_f_p_double_p_void__p_double,
  _swigc__p_f_p_q_const__double_p_void__double,
  _swigc__p_f_p_q_const__struct_GenericFunction_p_void__p_GenericFunction,
  _swigc__p_f_p_q_const__unsigned_long_p_void__double,
  _swigc__p_f_unsigned_long__double,
  _swigc__p_f_unsigned_long_p_q_const__double_p_double_p_void__double,
  _swigc__p_f_unsigned_long_p_q_const__double_p_double_p_void__int,
  _swigc__p_f_unsigned_long_p_q_const__double_p_double_unsigned_long_p_unsigned_long_p_struct_Data_p_struct_SLMemManager_p_void__double,
  _swigc__p_f_unsigned_long_p_q_const__double_unsigned_long_p_unsigned_long_p_struct_SLMemManager_p_struct_Data_p_p_double_p_p_double_p_void__int,
  _swigc__p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__double,
  _swigc__p_f_unsigned_long_unsigned_long_p_q_const__double_p_double_p_void__int,
  _swigc__p_ff,
  _swigc__p_fiber_info,
  _swigc__p_fiber_list,
  _swigc__p_func_type,
  _swigc__p_function_class,
  _swigc__p_int,
  _swigc__p_long_double,
  _swigc__p_mat,
  _swigc__p_p_CrossIndex,
  _swigc__p_p_FT1DArray,
  _swigc__p_p_FTMemSpace,
  _swigc__p_p_FiberCut,
  _swigc__p_p_FunctionTrain,
  _swigc__p_p_GenericFunction,
  _swigc__p_p_KernelExpansion,
  _swigc__p_p_LinElemExp,
  _swigc__p_p_LinElemExpAopts,
  _swigc__p_p_LinElemXY,
  _swigc__p_p_LinearTransform,
  _swigc__p_p_MultiApproxOpts,
  _swigc__p_p_ObjectiveFunction,
  _swigc__p_p_OneApproxOpts,
  _swigc__p_p_OpeOpts,
  _swigc__p_p_Operator,
  _swigc__p_p_OrthPolyExpansion,
  _swigc__p_p_PairList,
  _swigc__p_p_PiecewisePoly,
  _swigc__p_p_ProbabilityDensity,
  _swigc__p_p_PwPolyOpts,
  _swigc__p_p_QR,
  _swigc__p_p_Qmarray,
  _swigc__p_p_Quasimatrix,
  _swigc__p_p_c3Vector,
  _swigc__p_p_char,
  _swigc__p_p_double,
  _swigc__p_p_fiber_list,
  _swigc__p_p_mat,
  _swigc__p_p_p_GenericFunction,
  _swigc__p_p_sk_decomp,
  _swigc__p_p_storevals,
  _swigc__p_p_void,
  _swigc__p_sk_decomp,
  _swigc__p_storevals,
  _swigc__p_storevals_main,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_long,
  _swigc__p_void,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
        if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
          cast->type = ret;
          ret = 0;
        } else {
          /* Check for casting already in the list */
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
          if (!ocast) ret = 0;
        }
      }
      
      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{
  /* c-mode */
#endif
}
#endif



#ifdef __cplusplus
extern "C" {
#endif
  
  /* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
  
  /* -----------------------------------------------------------------------------
   * global variable support code.
   * ----------------------------------------------------------------------------- */
  
  typedef struct swig_globalvar {
    char       *name;                  /* Name of global variable */
    PyObject *(*get_attr)(void);       /* Return the current value */
    int       (*set_attr)(PyObject *); /* Set the value */
    struct swig_globalvar *next;
  } swig_globalvar;
  
  typedef struct swig_varlinkobject {
    PyObject_HEAD
    swig_globalvar *vars;
  } swig_varlinkobject;
  
  SWIGINTERN PyObject *
  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
    return PyUnicode_InternFromString("<Swig global variables>");
#else
    return PyString_FromString("<Swig global variables>");
#endif
  }
  
  SWIGINTERN PyObject *
  swig_varlink_str(swig_varlinkobject *v) {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *str = PyUnicode_InternFromString("(");
    PyObject *tail;
    PyObject *joined;
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      tail = PyUnicode_FromString(var->name);
      joined = PyUnicode_Concat(str, tail);
      Py_DecRef(str);
      Py_DecRef(tail);
      str = joined;
      if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        Py_DecRef(str);
        Py_DecRef(tail);
        str = joined;
      }
    }
    tail = PyUnicode_InternFromString(")");
    joined = PyUnicode_Concat(str, tail);
    Py_DecRef(str);
    Py_DecRef(tail);
    str = joined;
#else
    PyObject *str = PyString_FromString("(");
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
    }
    PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
    return str;
  }
  
  SWIGINTERN int
  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
    char *tmp;
    PyObject *str = swig_varlink_str(v);
    fprintf(fp,"Swig global variables ");
    fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(str);
    return 0;
  }
  
  SWIGINTERN void
  swig_varlink_dealloc(swig_varlinkobject *v) {
    swig_globalvar *var = v->vars;
    while (var) {
      swig_globalvar *n = var->next;
      free(var->name);
      free(var);
      var = n;
    }
  }
  
  SWIGINTERN PyObject *
  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
    PyObject *res = NULL;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->get_attr)();
        break;
      }
      var = var->next;
    }
    if (res == NULL && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN int
  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
    int res = 1;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->set_attr)(p);
        break;
      }
      var = var->next;
    }
    if (res == 1 && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN PyTypeObject*
  swig_varlink_type(void) {
    static char varlink__doc__[] = "Swig var link object";
    static PyTypeObject varlink_type;
    static int type_init = 0;
    if (!type_init) {
      const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
        PyVarObject_HEAD_INIT(NULL, 0)
#else
        PyObject_HEAD_INIT(NULL)
        0,                                  /* ob_size */
#endif
        (char *)"swigvarlink",              /* tp_name */
        sizeof(swig_varlinkobject),         /* tp_basicsize */
        0,                                  /* tp_itemsize */
        (destructor) swig_varlink_dealloc,  /* tp_dealloc */
        (printfunc) swig_varlink_print,     /* tp_print */
        (getattrfunc) swig_varlink_getattr, /* tp_getattr */
        (setattrfunc) swig_varlink_setattr, /* tp_setattr */
        0,                                  /* tp_compare */
        (reprfunc) swig_varlink_repr,       /* tp_repr */
        0,                                  /* tp_as_number */
        0,                                  /* tp_as_sequence */
        0,                                  /* tp_as_mapping */
        0,                                  /* tp_hash */
        0,                                  /* tp_call */
        (reprfunc) swig_varlink_str,        /* tp_str */
        0,                                  /* tp_getattro */
        0,                                  /* tp_setattro */
        0,                                  /* tp_as_buffer */
        0,                                  /* tp_flags */
        varlink__doc__,                     /* tp_doc */
        0,                                  /* tp_traverse */
        0,                                  /* tp_clear */
        0,                                  /* tp_richcompare */
        0,                                  /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
        0,                                  /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
        0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
        0,                                  /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
        0,                                  /* tp_allocs */
        0,                                  /* tp_frees */
        0,                                  /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
        0,                                  /* tp_prev */
#endif
        0                                   /* tp_next */
#endif
      };
      varlink_type = tmp;
      type_init = 1;
#if PY_VERSION_HEX < 0x02020000
      varlink_type.ob_type = &PyType_Type;
#else
      if (PyType_Ready(&varlink_type) < 0)
      return NULL;
#endif
    }
    return &varlink_type;
  }
  
  /* Create a variable linking object for use later */
  SWIGINTERN PyObject *
  SWIG_Python_newvarlink(void) {
    swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
    if (result) {
      result->vars = 0;
    }
    return ((PyObject*) result);
  }
  
  SWIGINTERN void 
  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
    swig_varlinkobject *v = (swig_varlinkobject *) p;
    swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
    if (gv) {
      size_t size = strlen(name)+1;
      gv->name = (char *)malloc(size);
      if (gv->name) {
        strncpy(gv->name,name,size);
        gv->get_attr = get_attr;
        gv->set_attr = set_attr;
        gv->next = v->vars;
      }
    }
    v->vars = gv;
  }
  
  SWIGINTERN PyObject *
  SWIG_globals(void) {
    static PyObject *_SWIG_globals = 0; 
    if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
    return _SWIG_globals;
  }
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------*/
  /* Fix SwigMethods to carry the callback ptrs when needed */
  /* -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods,
    swig_const_info *const_table,
    swig_type_info **types,
    swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              strncpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              strncpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
  PyObject *m, *d, *md;
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
# if PY_VERSION_HEX >= 0x03020000
    PyModuleDef_HEAD_INIT,
# else
    {
      PyObject_HEAD_INIT(NULL)
      NULL, /* m_init */
      0,    /* m_index */
      NULL, /* m_copy */
    },
# endif
    (char *) SWIG_name,
    NULL,
    -1,
    SwigMethods,
    NULL,
    NULL,
    NULL,
    NULL
  };
#endif
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    (PyCFunction) SwigPyObject_own,
    (PyCFunction) SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  PyTypeObject *swigpyobject;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* Metaclass is used to implement static member variables */
  metatype = SwigPyObjectType();
  assert(metatype);
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#if PY_VERSION_HEX >= 0x03000000
  m = PyModule_Create(&SWIG_module);
#else
  m = Py_InitModule((char *) SWIG_name, SwigMethods);
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  swigpyobject = SwigPyObject_TypeOnce();
  
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = swigpyobject;
  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
    return NULL;
# else
    return;
# endif
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  
  import_array();    
  
  SWIG_Python_SetConstant(d, "CROSS",SWIG_From_int((int)(CROSS)));
  SWIG_Python_SetConstant(d, "REGRESS",SWIG_From_int((int)(REGRESS)));
  SWIG_Python_SetConstant(d, "C3UNSPEC",SWIG_From_int((int)(C3UNSPEC)));
  SWIG_Python_SetConstant(d, "ALS",SWIG_From_int((int)(ALS)));
  SWIG_Python_SetConstant(d, "AIO",SWIG_From_int((int)(AIO)));
  SWIG_Python_SetConstant(d, "REGNONE",SWIG_From_int((int)(REGNONE)));
  SWIG_Python_SetConstant(d, "FTLS",SWIG_From_int((int)(FTLS)));
  SWIG_Python_SetConstant(d, "FTLS_SPARSEL2",SWIG_From_int((int)(FTLS_SPARSEL2)));
  SWIG_Python_SetConstant(d, "REGOBJNONE",SWIG_From_int((int)(REGOBJNONE)));
  SWIG_Python_SetConstant(d, "LINEAR_ST",SWIG_From_int((int)(LINEAR_ST)));
  SWIG_Python_SetConstant(d, "NONE_ST",SWIG_From_int((int)(NONE_ST)));
  SWIG_Python_SetConstant(d, "PIECEWISE",SWIG_From_int((int)(PIECEWISE)));
  SWIG_Python_SetConstant(d, "POLYNOMIAL",SWIG_From_int((int)(POLYNOMIAL)));
  SWIG_Python_SetConstant(d, "CONSTELM",SWIG_From_int((int)(CONSTELM)));
  SWIG_Python_SetConstant(d, "LINELM",SWIG_From_int((int)(LINELM)));
  SWIG_Python_SetConstant(d, "KERNEL",SWIG_From_int((int)(KERNEL)));
  SWIG_Python_SetConstant(d, "PARAMETRIC",SWIG_From_int((int)(PARAMETRIC)));
  SWIG_Python_SetConstant(d, "NONPARAMETRIC",SWIG_From_int((int)(NONPARAMETRIC)));
  SWIG_Python_SetConstant(d, "LS",SWIG_From_int((int)(LS)));
  SWIG_Python_SetConstant(d, "RLS2",SWIG_From_int((int)(RLS2)));
  SWIG_Python_SetConstant(d, "RLSD2",SWIG_From_int((int)(RLSD2)));
  SWIG_Python_SetConstant(d, "RLSRKHS",SWIG_From_int((int)(RLSRKHS)));
  SWIG_Python_SetConstant(d, "RLS1",SWIG_From_int((int)(RLS1)));
  SWIG_Python_SetConstant(d, "SQRTPIINV",SWIG_From_double((double)(0.631618777746064701290010510108243075846860739510341013477)));
  PyDict_SetItemString(md,(char *)"cvar", SWIG_globals());
  SWIG_addvarlink(SWIG_globals(),(char *)"lpolycoeffs",Swig_var_lpolycoeffs_get, Swig_var_lpolycoeffs_set);
  SWIG_Python_SetConstant(d, "M_PI",SWIG_From_double((double)(3.14159265358979323846264338327)));
  SWIG_Python_SetConstant(d, "NONE",SWIG_From_int((int)(NONE)));
  SWIG_Python_SetConstant(d, "ALGEBRAIC",SWIG_From_int((int)(ALGEBRAIC)));
  SWIG_Python_SetConstant(d, "EXPONENTIAL",SWIG_From_int((int)(EXPONENTIAL)));
  SWIG_Python_SetConstant(d, "LEGENDRE",SWIG_From_int((int)(LEGENDRE)));
  SWIG_Python_SetConstant(d, "CHEBYSHEV",SWIG_From_int((int)(CHEBYSHEV)));
  SWIG_Python_SetConstant(d, "HERMITE",SWIG_From_int((int)(HERMITE)));
  SWIG_Python_SetConstant(d, "STANDARD",SWIG_From_int((int)(STANDARD)));
  SWIG_Python_SetConstant(d, "FOURIER",SWIG_From_int((int)(FOURIER)));
  SWIG_Python_SetConstant(d, "OPECALLOC",SWIG_From_int((int)(50)));
  SWIG_Python_SetConstant(d, "BACKTRACK",SWIG_From_int((int)(BACKTRACK)));
  SWIG_Python_SetConstant(d, "STRONGWOLFE",SWIG_From_int((int)(STRONGWOLFE)));
  SWIG_Python_SetConstant(d, "WEAKWOLFE",SWIG_From_int((int)(WEAKWOLFE)));
  SWIG_Python_SetConstant(d, "BFGS",SWIG_From_int((int)(BFGS)));
  SWIG_Python_SetConstant(d, "LBFGS",SWIG_From_int((int)(LBFGS)));
  SWIG_Python_SetConstant(d, "BATCHGRAD",SWIG_From_int((int)(BATCHGRAD)));
  SWIG_Python_SetConstant(d, "BRUTEFORCE",SWIG_From_int((int)(BRUTEFORCE)));
  SWIG_Python_SetConstant(d, "SGD",SWIG_From_int((int)(SGD)));
  SWIG_Python_SetConstant(d, "C3OPT_LS_PARAM_INVALID",SWIG_From_int((int)(C3OPT_LS_PARAM_INVALID)));
  SWIG_Python_SetConstant(d, "C3OPT_LS_MAXITER_REACHED",SWIG_From_int((int)(C3OPT_LS_MAXITER_REACHED)));
  SWIG_Python_SetConstant(d, "C3OPT_X_BOUND_VIOLATED",SWIG_From_int((int)(C3OPT_X_BOUND_VIOLATED)));
  SWIG_Python_SetConstant(d, "C3OPT_MAXITER_REACHED",SWIG_From_int((int)(C3OPT_MAXITER_REACHED)));
  SWIG_Python_SetConstant(d, "C3OPT_SUCCESS",SWIG_From_int((int)(C3OPT_SUCCESS)));
  SWIG_Python_SetConstant(d, "C3OPT_FTOL_REACHED",SWIG_From_int((int)(C3OPT_FTOL_REACHED)));
  SWIG_Python_SetConstant(d, "C3OPT_XTOL_REACHED",SWIG_From_int((int)(C3OPT_XTOL_REACHED)));
  SWIG_Python_SetConstant(d, "C3OPT_GTOL_REACHED",SWIG_From_int((int)(C3OPT_GTOL_REACHED)));
  SWIG_Python_SetConstant(d, "LT",SWIG_From_int((int)(LT)));
  SWIG_Python_SetConstant(d, "SYMMETRIC",SWIG_From_int((int)(SYMMETRIC)));
  SWIG_Python_SetConstant(d, "GEN",SWIG_From_int((int)(GEN)));
  SWIG_Python_SetConstant(d, "GAUSSIAN",SWIG_From_int((int)(GAUSSIAN)));
  SWIG_Python_SetConstant(d, "GENERAL",SWIG_From_int((int)(GENERAL)));
  SWIG_Python_SetConstant(d, "GAUSSIAN_LIKE",SWIG_From_int((int)(GAUSSIAN_LIKE)));
  SWIG_Python_SetConstant(d, "POISSON_LIKE",SWIG_From_int((int)(POISSON_LIKE)));
  SWIG_Python_SetConstant(d, "GENERIC_LIKE",SWIG_From_int((int)(GENERIC_LIKE)));
  SWIG_Python_SetConstant(d, "C3_GAUSS_QUAD",SWIG_From_int((int)(C3_GAUSS_QUAD)));
  SWIG_Python_SetConstant(d, "C3_CC_QUAD",SWIG_From_int((int)(C3_CC_QUAD)));
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

